text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Знаете ли вы как работает этот код?
Вчера, в очередной раз столкнувшись с интересным поведением кода, я решил привести пару примеров из C# и MS SQL, которые в свое время меня удивили.
#### Пример 1. Меняем местами значения переменных (C#)
С этим поведением я встретился несколько лет назад, когда только начал изучать C#. Применив знакомый метод, чтобы поменять значения 2-х переменных местами, я с удивлением обнаружил, что он не работает.
> `//Задаем 2 переменные
>
> int x = 1, y = 2;
>
>
>
> //Меняем их значения при помощи xor
>
> x ^= y;
>
> y ^= x;
>
> x ^= y;
>
>
>
> //Выводим результат [x=2;y=1]
>
> Console.WriteLine("x = {0};y = {1}", x, y);
>
>
>
> //Снова меняем их значения, но только пишем все в одну строчку
>
> x ^= y ^= x ^= y;
>
>
>
> //Выводим результат [x=0;y=2]
>
> Console.WriteLine("x = {0};y = {1}", x, y);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В итоге, в первый раз все проходит нормально и значения переменных меняются, а во второй раз, вопреки ожиданиям, у нас обнуляется переменная x.
#### Пример 2. Переводим число в строку (MS SQL)
Вот пример того, как функции cast и convert могут приподносить сюрпризы.
> `cast(1000 as varchar(3)) --Результатом будет '\*'
>
> cast(1000 as nvarchar(3)) --Результатом будет Error
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Хотя такое поведение и задокументировано в MSDN, столкнулся я с этим раньше чем прочитал о нем.
#### Пример 3. Использование NOT IN и IN в условии(MS SQL)
Этот пример также описан в MSDN, но узнал я о таком поведении, только когда из-за него произошла ошибка в программе.
> `--Создадим тестовую таблицу
>
> create table #tmpTable
>
> (
>
> id int
>
> )
>
>
>
> /\*Заполним ее числами от 1 до 10\*/
>
>
>
> --Теперь выполним пару select'ов
>
> select \* from #tmpTable where id in (1,2,null,3) --Результат: 3 строки
>
> select \* from #tmpTable where id not in (1,2,null,3)--Результат: 0 строк
>
>
>
> --Не забудем таблицу удалить
>
> drop table #tmpTable
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В отличие от IN, который просто пропускает null, NOT IN всегда возвращает пустую выборку. В общем-то, после небольших размышлений, на тему «почему так?», результат уже не кажется необычным.
#### Пример 4. Finally и необработанное исключение(C#)
Следующая ситуация мне кажется необычной, потому что меняет поведение в зависимости от того, ловите ли вы исключение или нет.
Итак, напишем класс с одним методом, в котором будет блок try-catch-finally. Вызов метода также обернем в try-catch.
> `class C
>
> {
>
> public void F()
>
> {
>
> try
>
> {
>
> Console.WriteLine("Try");
>
> throw new Exception("some exception");
>
> }
>
> catch(Exception ex)
>
> {
>
> Console.WriteLine("F Catch");
>
> throw ex;
>
> }
>
> finally
>
> {
>
> Console.WriteLine("Finally");
>
> }
>
> }
>
> }
>
>
>
> static void Main(string[] args)
>
> {
>
> try
>
> {
>
> C c = new C();
>
> c.F();
>
> }
>
> catch (Exception)
>
> {
>
> Console.WriteLine("Main catch");
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Все сработает так как и должно:
1.Try
2.F Catch
3.Finally
4.Main catch
Теперь уберем из метода Main блок try-catch и снова запустим программу. На этот раз результат будет немного другой, хотя в обоих случаях exception покидает метод F():
1.Try
2.F Catch
3.Информация об ошибке
4.Finally
#### Заключение
В большинстве случаев, необычное с первого взгляда поведение, оказывается вполне объянимым или уже задокументированным. Но, согласитесь, что мало кто досконально читает help перед тем как писать код. Так что желаю вам пореже встречаться с такими сюрпризами. | https://habr.com/ru/post/91210/ | null | ru | null |
# Основы Linux (обзор с практическим уклоном)
Привет, Хабр!
В последние несколько лет все больше и больше людей ищут возможность войти в ИТ или поглубже изучить Linux, повысив уровень своей квалификации. Вместе с тем полноценных обзоров с практическим уклоном по типу «все и сразу» написано не так уж и много (особенно на русском языке).
Главная задача данной статьи – указать начинающим специалистам направление развития, дать ключевые понятия для дальнейшего изучения и показать несколько простых практических приемов. По этой причине (а еще, безусловно, вследствие недостаточной квалификации автора) теоретический материал достаточно сильно упрощен.
Что такое Linux?
----------------
### История и определение
В 1969 году в дочернем подразделении компании AT&T – Bell Laboratories – была выпущена операционная система Unix, которая стала основной для большого количества операционных систем того времени. UNIX была проприетарной системой, лицензия на нее стоила порядка 40 000 долларов. Таким образом, позволить себе ее покупку могли только крупные компании. Это послужило толчком для старта в 1983 году проекта [GNU](https://www.gnu.org/) – GNU is Not Unix. Его основоположник, [Ричард Столлман](https://en.wikipedia.org/wiki/Richard_Stallman), объявил целью проекта создание свободно распространяемой операционной системы. Чуть позже Столлманом был написан знаменитый [манифест GNU](https://www.gnu.org/gnu/manifesto.html), который стал основой для лицензии [GPL](https://www.gnu.org/licenses/gpl-3.0.html) (GNU General Public License), актуальной и по сей день. К началу 1990-х годов в рамках проекта GNU было написано большинство компонентов ОС – оболочка bash, компиляторы, отладчик, текстовый редактор и др. Не хватало лишь ядра операционной системы.
В 1991 году [Линус Торвальдс](https://en.wikipedia.org/wiki/Linus_Torvalds), будучи студентом финского университета, увлекся идеей написания ядра операционной системы для своего персонального компьютера с процессором Intel. Вдохновлением и прототипом для будущего Linux стала совместимая с Unix операционная система для персональных компьютеров Minix. Уже в августе 1991 года было написано ядро операционной системы, в нее были портированы оболочка bash и компилятор gсс из проекта GNU. По признанию самого Линуса, изначально это было не более, чем хобби, однако проект оказался весьма востребованным, к нему начали присоединяться разработчики со всего мира. Дополненная массой программ, разработанных в рамках проекта GNU, ОС Linux стала пригодна для практического использования. При этом ядро системы распространялось под лицензией GNU General Public License, что гарантировало свободное распространение кода ядра системы.
Читать подробнее: [История Linux. Вкратце о главном](https://habr.com/ru/post/95646/)
Итак, сегодня [Linux (или GNU/Linux)](https://en.wikipedia.org/wiki/Linux) – семейство Unix-подобных операционных систем на базе ядра Linux, включающих тот или иной набор утилит и программ проекта GNU. Linux-системы распространяются в виде различных дистрибутивов, имеющих свой набор системных и прикладных компонентов (как свободных, так и проприетарных).
### Серверные дистрибутивы
[Дистрибутив Linux](https://en.wikipedia.org/wiki/Linux_distribution) — это операционная система, созданная на основе ядра Linux, которая включает в себя набор библиотек и утилит (пакетов), разработанных в рамках проекта GNU, а также систему управления пакетами (менеджер пакетов). В настоящее время существует более 500 различных дистрибутивов, разрабатываемых как при коммерческой поддержке ([Red Hat](https://ru.wikipedia.org/wiki/Red_Hat) / [Fedora](https://ru.wikipedia.org/wiki/Fedora), [SLED](https://ru.wikipedia.org/wiki/SLED) / [OpenSUSE](https://ru.wikipedia.org/wiki/OpenSUSE), [Ubuntu](https://ru.wikipedia.org/wiki/Ubuntu) и др.), так и исключительно усилиями добровольцев ([Debian](https://ru.wikipedia.org/wiki/Debian), [Slackware](https://ru.wikipedia.org/wiki/Slackware), [Gentoo](https://ru.wikipedia.org/wiki/Gentoo), [ArchLinux](https://ru.wikipedia.org/wiki/ArchLinux) и др.).
Дистрибутивы делятся на несколько типов в зависимости от базового дистрибутива и системы управления пакетами. Вот несколько примеров наиболее популярных серверых дистрибутивов двух типов:
* [RPM-based](https://en.wikipedia.org/wiki/List_of_Linux_distributions#RPM-based) (используют формат пакетов .rpm)
RedHat Enterprise Linux, CentOS, Fedora
* [DEB-based](https://en.wikipedia.org/wiki/List_of_Linux_distributions#DEB-based) (используют формат пакетов .deb)
Debian, Ubuntu, Astra Linux
Стоит отметить, что существует великое множество различных дистрибутивов на любой вкус и цвет. Их невозможно даже сосчитать, так как практически каждый представитель сообщества может собрать свой собственный дистрибутив на основе ядра Linux.
Работа с Linux
--------------
### Загрузка
Алгоритм включения сервера и загрузки Linux в большинстве случаев выглядит следующим образом:
* [BIOS](https://en.wikipedia.org/wiki/BIOS) / [UEFI](https://en.wikipedia.org/wiki/UEFI) → [MBR](https://en.wikipedia.org/wiki/Master_boot_record) / [GPT](https://en.wikipedia.org/wiki/GUID_Partition_Table)
Выполняется код, заложенный производителем аппаратного обеспечения. Этот код проводит тестирование системы POST (Power On Self Test) и передает управление загрузчику в MBR (Master Boot Record) / GPT (GUID Partition Table)
* MBR / GPT → [GRUB2](https://en.wikipedia.org/wiki/GNU_GRUB#GRUB_2) (существуют и другие загрузчики)
Загрузчик из MBR / GPT очень простой – он способен только найти на диске и запустить следующий загрузчик. Как правило это GRUB2, но существуют и другие загрузчики, например [LILO](https://en.wikipedia.org/wiki/LILO_(boot_loader)) (в настоящее время практически не используется)
* GRUB2 → Kernel
GRUB2 расположен на разделе жесткого диска в каталоге /boot. GRUB2 загружает ядро Linux (vmlinuz)
* Kernel → Init
Ядро запускает процесс инициализации операционной системы. Как правило это SystemD, но существуют и другие системы инициализации, например [SystemV](https://en.wikipedia.org/wiki/UNIX_System_V) (в настоящее время практически не используется). Процесс инициализации запускает все остальные процессы в системе
Читать подробнее: [Алгоритм загрузки Linux (BIOS / UEFI)](https://sysadminium.ru/adm_serv_linux-boot_algorithm)
### Подключение
#### Командная оболочка
Подключиться к Linux для управления можно в интерфейсе командной строки (command-line interface, CLI) или в графическом интерфейсе (graphical user interface, GUI). При работе с серверной инфраструктурой в подавляющем числе случаев GUI отсутствует и взаимодействие с сервером осуществляется в CLI. При входе пользователя на сервер в CLI запускается командная оболочка (в GUI командную оболочку можно запустить через эмулятор, например Terminal). Командная оболочка (shell) – это программа, которая принимает команды с клавиатуры и передает их операционной системе для выполнения. Наиболее распространенной командной оболочкой в Linux является [GNU bash](https://www.gnu.org/software/bash/) (Bourne Again SHell). bash основывается на другой легковесной оболочке-предшественнике – [sh](https://en.wikipedia.org/wiki/Bourne_shell) (Bourne sh), созданной [Стефеном Борном](https://en.wikipedia.org/wiki/Stephen_R._Bourne).
Команды можно выполнять с помощью командной строки, указав имя двоичного (бинарного, bin) исполняемого файла или сценария. По умолчанию в Linux много команд, которые позволяют перемещаться по файловой системе, устанавливать ПО, конфигурировать его и выполнять другие действия. Каждая запущенная команда является отдельным процессом. Важно отметить, что в Linux (в отличие от Windows) почти всегда учитывается регистр, включая имена файлов и каталогов, команды, аргументы и опции.
Читать подробнее: [Основы работы с терминалом Linux](https://www.8host.com/blog/osnovy-raboty-s-terminalom-linux)
#### SSH
Подключаться к Linux и работать с командной оболочкой можно локально (например включив ПК дома или подойдя к серверу в центре обработки данных), однако гораздо чаще работать с системой требуется удаленно. Для этого необходимо настроить SSH и подключаться через него. [SSH](https://en.wikipedia.org/wiki/SSH) (Secure SHell) – это протокол, позволяющий производить удаленное управление операционной системой и туннелирование TCP-соединений (например, для копирования файлов). SSH основан на клиент-серверной архитектуре, которая организует защищенное (зашифрованное) соединение поверх небезопасных каналов связи. Серверная часть устанавливается на удаленном сервере, а клиентская на компьютере, с которого осуществляется подключение.
Существует много клиентов для удаленного подключения к серверу по SSH. Вот несколько примеров для различных операционных систем:
* Windows
[PuTTY](https://www.putty.org/) – выбор новичка, PowerShell (команда ssh), [Xshell](https://www.netsarang.com/en/xshell/) – выбор автора, [MobaXterm](https://mobaxterm.mobatek.net/), [mRemoteNG](https://mremoteng.org/)
* Linux
Terminal (команда ssh) – выбор новичка и автора, [Asbru Connection Manager](https://www.asbru-cm.net/)
* MacOS
Terminal (команда ssh) – выбор новичка и автора, [Core Shell](https://codinn.com/shell/)
Читать подробнее:
* [SSH](http://xgu.ru/wiki/SSH)
* [Как подключиться по SSH](https://losst.ru/kak-podklyuchitsya-po-ssh)
* [Лучшие SSH клиенты для Windows, Linux и MacOS](https://timeweb.com/ru/community/articles/luchshie-ssh-klienty-dlya-windows-linux-i-macos)
### Установка программ (утилит) пакетным менеджером
#### Зачем нужны пакетные менеджеры?
На заре развития Linux установить приложение (утилиту) можно было только путем скачивания исходного кода программы и компиляции. Это не практично и не слишком удобно для пользователей, поэтому были разработаны [пакетные менеджеры](https://en.wikipedia.org/wiki/Package_manager). Установка приложений в них производится из пакетов – архивов с файлами скомпилированной программы. Большинство популярных дистрибутивов Linux содержат пакетные менеджеры, способные устанавливать любое программное обеспечение. Пакетные менеджеры имеют свой список репозиториев – серверов с базой пакетов. Во время установки алгоритм менеджера находит необходимый пакет в базе и производит автоматическое скачивание, установку и настройку.
Существует несколько форматов пакетов, однако наибольшее распространение получили .deb и .rpm. Рассмотрим операционные системы и менеджеры пакетов для данных форматов:
* DEB (.deb)
ОС – DEB-based, например Debian, Ubuntu, AstraLinux
Система управления пакетами – [DPKG](https://en.wikipedia.org/wiki/Dpkg) (работает только с локальными пакетами)
Пакетный менеджер – [apt](https://en.wikipedia.org/wiki/APT_(software))
* RPM (.rpm)
ОС – RPM-based, например RedHat Enterprise Linux, Fedora, CentOS
Система управления пакетами – [RPM](https://en.wikipedia.org/wiki/RPM_Package_Manager) (работает только с локальными пакетами)
Пакетный менеджер – [yum](https://en.wikipedia.org/wiki/Yum_(software)) (в последних дистрибутивах заменен на [dnf](https://en.wikipedia.org/wiki/DNF_(software)))
Читать подробнее: [Популярные пакетные менеджеры Linux](https://eternalhost.net/blog/sistemnoe-administrirovanie/paketnye-menedzhery-linux)
#### Практика
На практике пользователю необходимо уметь взаимодействовать с пакетными менеджерами – устанавливать и удалять пакеты.
Ниже приведены несколько примеров команд:
```
# руководство (справочная информация)
man # просмотр справочной информации по утилите
--help # просмотр справочной информации по утилите
# менеджер пакетов apt (.deb)
sudo apt install nano # установка пакета
sudo apt remove nano # удаление пакета
sudo apt autoclean # удаление кэша пакетов
# менеджер пакетов yum (.rpm) - для dnf команды полностью аналогичны
sudo yum install nano # установка пакета
sudo yum remove nano # удаление пакета
sudo yum clean all # удаление кэша пакетов
```
При необходимости уточняйте описание утилит и ключей выполнения в Интернете или в руководстве man.
### Структура файловой системы и работа с файлами
#### Типы файлов
Все объекты в Linux являются файлами. Существуют следующие типы файлов:
* Обычные файлы **-**Символьные и двоичные данные (текст, картинки, программы и др.)
* Каталог (директория) **d**Список ссылок на файлы или другие каталоги
* Символьные ссылки **l**Ссылки на другие файлы по имени
* Блочные устройства **b,** символьные устройства **c**Интерфейсы для взаимодействия с аппаратным обеспечением (диски, терминалы, клавиатуры, принтеры и др.). Когда происходит обращение к файлу устройства, ядро операционной системы передает запрос драйверу этого устройства
* Сокеты **s** и каналы **p**
Интерфейсы для взаимодействия процессов
Читать подробнее: [Типы файлов в Linux](https://younglinux.info/bash/filestype)
#### Структура файловой системы
Структура файловой системы представляет собой дерево, корнем которой является каталог /.
Рассмотрим подробно структуру и назначение каталогов:
* /bin (binaries) – исполняемые файлы самых необходимых утилит. Может быть символьной ссылкой на /usr/bin
* /boot – файлы, необходимые для самого первого этапа загрузки – загрузки ядра (и обычно само ядро)
* /dev (devices) – блочные и символьные файлы устройств (диски, терминалы, клавиатуры, принтеры и др.)
* /etc (etcetera) – конфигурационные файлы системы и различных программ
* /home – домашние каталоги пользователей для хранения «личных» файлов
* /lib (libraries) – файлы библиотек (стандартных функций, необходимых многим программам), необходимых для работы утилит. Может быть символьной ссылкой на /usr/bin
* /mnt (mount) – каталог для подключения файловых систем (съемных носителей и др.)
* /opt (optional) – каталог для дополнительных программ (проприетарных драйверов, агентов мониторинга и др.)
* /proc (process) – файлы в оперативной памяти, в которых содержится информация о выполняемых в системе процессах
* /root – домашний каталог пользователя root
* /sbin (system binaries) – файлы системных утилит, необходимые для загрузки, резервного копирования и восстановления системы. Может быть символьной ссылкой на /usr/sbin
* /sys (system) – виртуальная файловая система sysfs, которая содержит информацию об аппаратном обеспечении (ЦПУ, ОЗУ, дисках, сетевых устройствах), драйверах, ядре системы и др.
* /tmp – каталог для временных файлов, обычно зачищается при каждой загрузке системы
* /usr – пользовательский каталог, который содержит каталоги исполняемых файлов и конфигурационных файлов
* /var (variable) – файлы, создаваемые или используемые различными программами (логи, очереди, идентификаторы процессов, БД и др.)
Читать подробнее: [Структура файловой системы Linux](https://serverspace.ru/support/help/struktura-fajlovoj-sistemy-linux/)
#### Права доступа
В Linux права доступа к файлам (в том числе к каталогам) задаются для трех видов пользователей – владельца, группы владельца и остальных. Также есть три типа доступа к файлу – чтение **r** (Read), запись **w** (Write) и исполнение **x** (eXecution), которые задаются для каждого из видов пользователей. Прочерк **-** означает отсутствие доступа.
Таким образом, права доступа к файлу выглядят следующим образом:
* права для владельца (u, user) – read, write, execution
* права для группы владельца (g, group) – read, write, execution
* права для остальных пользователей (o, other) – read, write, execution
Пример: rwx r-- --- означает, что у владельца есть права на все, у группы владельца доступ только на чтение, а у остальных доступа нет. В двоичной системе счисления эти права выглядят как три группы цифр – 111 100 000, что равносильно трем цифрам 7 4 0 в восьмеричной и десятичной системах счисления.
Читать подробнее:
* [Владельцы файлов и папок в Linux](https://wiki.merionet.ru/servernye-resheniya/87/vladelcy-fajlov-i-papok-v-linux/)
* [Команда chmod в Linux](https://losst.ru/komanda-chmod-linux)
#### Практика
На практике пользователю необходимо осуществлять навигацию по системе, просматривать, создавать, редактировать и удалять файлы, настраивать права доступа.
Ниже приведены несколько примеров наиболее часто используемых команд:
```
# руководство (справочная информация)
man # просмотр справочной информации по утилите
--help # просмотр справочной информации по утилите
# навигация
ls -la # просмотр содержимого каталога (в том числе прав доступа)
cd # переход в каталог
# каталоги
mkdir # создание каталога
rmdir # удаление пустого каталога
rm -rf # удаление каталога с файлами
# файлы
cat # вывод файла в консоль
less # постраничный вывод файла
tail # вывод последних строк («хвоста») файла
vi # редактиврование файла текстовым редактором vi
nano # редактирование файла текстовым редактором nano
cp # копирование файла в каталог
mv # перемещение файла в каталог (для переименования переместите файл в тот же каталог)
rm # удаление файла
rm -rf /\* # удаление всех файлов в каталоге
# права доступа
chown # установить пользователя владельцем каталога
chown : # установить владельца и группу владельца каталога
chmod 644 # установить права доступа rw- r-- r-- (чтение и запись для владельца, чтение для группы владельца, чтение для остальных пользователей)
сhmod 740 # установить права доступа rwx r-- --- (чтение, запись и исполнение для владельца, чтение для группы владельца)
chmod u+w # добавить владельцу право на запись файла
```
При необходимости уточняйте описание утилит и ключей выполнения в Интернете или в руководстве man.
### Процессы и потребление ресурсов сервера
#### Процессы
Если предельно упростить, то процесс – это любая программа, которая выполняется в системе. В ходе работы с системой может быть запущено множество программ, которые, в свою очередь, могут запустить множество процессов. Простейший пример процесса – командная оболочка bash. Каждому процессу в Linux присваивается уникальный идентификатор процесса (PID), который используется ядром для управления процессом до завершения программы или команды, с которой он связан.
Процесс может находиться в следующих статусах:
* Выполнение (**R**, Running)
Выполнение или ожидание ЦПУ для выполнения
* Сон (**S**, Sleep)
Прерываемое программно ожидание
* Непрерываемый сон (**D**, Direct)
Ожидание «прямого» сигнала от аппаратной части для прерывания
* Приостановлен (**T**, Tracing)
Отладка
* Зомби (**Z**, Zombie)
Выполнение завершено, однако ресурсы не освобождены
Почти любой процесс (кроме процесса в статусе D) может быть принудительно прерван администратором в случае необходимости («убит»). Это не всегда безопасно, однако возможно.
Запущенные процессы требуют использования аппаратных ресурсов сервера – ЦПУ, ОЗУ, дисков, сетевых интерфейсов.
Читать подробнее: [Процессы в Linux](https://www.k-max.name/linux/processy-v-linux/)
#### Практика
На практике пользователю необходимо просматривать списки процессов и останавливать процессы, а также просматривать имеющиеся и потребляемые ресурсы сервера в системе.
Ниже приведены несколько примеров наиболее часто используемых команд:
```
# руководство (справочная информация)
man # просмотр справочной информации по утилите
--help # просмотр справочной информации по утилите
# процессы
top
sudo ps aux
sudo kill -9 # убийство процесса по PID
sudo killall -s 9 # убийство всех процессов по имени
# утилиты для мониторинга использования ресурсов
htop # использование ресурсов по процессам (может потребоваться установка пакета htop)
nmon # использование процессора по ядрам, памяти, дисков и др. (может потребоваться установка пакета nmon)
iostat # использование процессора в среднем по ядрам и чтение/запись по дискам
# ЦПУ
lscpu # общая информация
cat /proc/cpuinfo # подробная информация
# ОЗУ
cat /proc/meminfo # общая информация и потребление
free -h # удобное представление на основе данных из файла meminfo
ps aux --sort -rss # использование памяти по процессам
# диски
lsblk # общая информация
df -h # просмотр занятного места по разделам
du -сh # просмотр занятого места в каталоге
# сеть
/sys/class/net//speed # просмотр максимальной скорости интерфейса
```
При необходимости уточняйте описание утилит и ключей выполнения в Интернете или в руководстве man.
### Программный комплекс systemd
#### Зачем нужен systemd?
[SystemD](https://en.wikipedia.org/wiki/Systemd) – это программный комплекс, состоящий из системных компонентов Linux. Основным компонентом является система инициализации системы SystemD, которая пришла на смену [SystemV](https://en.wikipedia.org/wiki/UNIX_System_V) в большинстве современных дистрибутивов. Ядро Linux запускает процесс systemd, который, в свою очередь, запускает все остальные процессы системы.
SystemD предоставляет следующий функционал:
* Запуск служб при старте системы (по возможности параллельно) по различным таргетам (target, аналог уровней загрузки в SystemV)
Обеспечивается обратная совместимость с системами инициализации SystemV и LSB
* Контроль состояния запущенных служб
* Управление устройствами, входом в систему, сетевыми подключениями, ведение журнала событий
* Интерфейсы для реализации функциональных возможностей ядра – cgroups, autofs, kdbus
* Набор утилит для управления системой – systemctl, journalctl и др.
### Что такое systemd unit?
[SystemD Unit](https://www.freedesktop.org/software/systemd/man/systemd.unit.html) – это обычный текстовый файл в стиле ini, который декларативно описывает информацию о службах .service, устройствах .device, целях запуска .target и других типах модулей systemd.
Описание юнита состоих из нескольких секций:
* Unit
Description (краткое описание), After (ожидание запуска), Requires (обязательная зависимость) и др.
* Service
Type (тип) – по умолчанию Simple, ExecStart (команда для запуска), ExecStop (команда для остановки) и др.
* Install
WantedBy (таргет или уровень запуска, на котором юнит должен запуститься)
Файлы systemd unit располагаются в следующих каталогах:
* /etc/systemd/system – юниты, создаваемые администраторами
* /usr/lib/systemd/system – юниты из установленых пакетов
* /run/systemd/system – юниты, создаваемые во время работы системы (в runtime)
Редактировать и создавать юниты можно с помощью текстового редактора (например vi или nano).
Читать подробнее:
* [Применение systemd: только самое главное](https://highload.today/systemd-linux/)
* [Понимание systemd юнитов](https://max-ko.ru/9-systemd-i-junity.html)
* Примеры systemd unit – [NGINX](https://www.nginx.com/resources/wiki/start/topics/examples/systemd/), [Apache](https://httpd.apache.org/docs/trunk/mod/mod_systemd.html)
#### Практика
На практике пользователю необходимо просматривать различные systemd unit, просматривать их содержимое и управлять сервисами, а также читать журналы логов.
Ниже приведены несколько примеров наиболее часто используемых команд:
```
# руководство (справочная информация)
man # просмотр справочной информации по утилите
--help # просмотр справочной информации по утилите
# просмотр юнитов
systemctl # список юнитов (это псевдоним команды systemctl list-units)
systemctl --type=service # юниты типа сервисы
systemct | grep # юниты, содержащие ключевое слово (полезно для быстрого поиска)
systemctl cat # описание юнита
# управление юнитами
systemctl status # статус (состояние) юнита
sudo systemctl daemon-reload # перезагрузка конфигурационных файлов в systemd
sudo systemctl enable # включение сервиса в автозагрузку
sudo systemctl disable # отключение сервиса из автозагрузки
sudo systemctl start # запуск
sudo systemctl stop # остановка
# журналы логов
journalctl -u # чтение логов по юниту
journalctl -u --since today # чтение логов по юниту со смены дня
```
При необходимости уточняйте описание утилит и ключей выполнения в Интернете или в руководстве man.
### Сеть
На практике пользователю необходимо уметь просматривать сетевые настройки сервера, а также уметь проводить простейшую диагностику сетевых проблем.
Ниже приведены несколько примеров наиболее часто используемых команд:
```
# руководство (справочная информация)
man # просмотр справочной информации по утилите
--help # просмотр справочной информации по утилите
# просмотр сетевых настроек сервера
ip a # IP адреса
ip n # ARP таблица
cat /etc/resolv.conf # конфигурация DNS
sudo netstat -tulpn # открытые порты
sudo ss -tulpn # открытые порты (молодежный вариант)
# диагностика сетевых проблем
nslookup # проверка разрешения DNS имени
ping # отправка ICMP пакетов до хоста
traceroute # трассировка до хоста UDP пакетами
telnet # проверка доступности TCP порта на хосте
nmap # сетевое сканирование хоста
nmap -p T: # проверка доступности TCP порта на хосте (молодежный вариант)
nmap -p U: # проверка доступности UDP порта на хосте (молодежный вариант)
```
При необходимости уточняйте описание утилит и ключей выполнения в Интернете или в руководстве man.
---
Все статьи серии:
1. [Основы Linux (обзор с практическим уклоном)](https://habr.com/ru/post/655275/)
2. [Основы виртуализации (обзор)](https://habr.com/ru/post/657677/)
3. [Основы контейнеризации (обзор Docker и Podman)](https://habr.com/ru/post/659049/)
4. [Основы мониторинга (обзор Prometheus и Grafana)](https://habr.com/ru/post/709204/) | https://habr.com/ru/post/655275/ | null | ru | null |
# Как написать пассивный доход: Пишем качественного трейд бота на JS (часть 1)
Начнем писать трейдинг бота, который будет работать на криптобирже Binance. Бот должен уметь:
1. торговать самостоятельно, принося какой-то доход
2. должен быть удобен для создания и обкатывания различных стратегий торговли
3. тестировать стратегию на исторических данных
Пожалуй, начнем с архитектуры
-----------------------------
У нас есть биржа Binance, у которой есть шикарное api. Поэтому архитектура могла бы выглядеть так:
Вызвать пару методов “купи дешевле” и “продай дороже”. Но задача для нас написать такого бота, при котором условный программист-трейдер сможет создавать и тестировать на прибыльность новые стратегии. Поэтому, необходимо отделить логику торговли от всего прочего. А также модулю логики должно быть все равно к какой бирже его подключили: к реальному API или к псевдо-API (для тестирования). С учетом всего этого получилась примерно вот такая архитектура:
Базу выбрал PostgreSQL. Тут нет никакого тайного умысла. Вы можете использовать любую.
В связи с тем, что каждый модуль стоит внимания, это все не поместится в одну статью. Поэтому я начинаю мини-сериал: "Пишем качественного трейд бота на JS". Поэтому подписывайтесь, устраивайтесь поудобней - начинаем
Сервис для логов
----------------
Простой класс, который принимает на вход префикс для логирования и имеет два метода `log` и `error`. Эти методы печатают лог с текущим временем и перфиксом:
```
class LoggerService {
constructor(prefix) {
this.logPrefix = prefix
}
log(...props) {
console.log(new Date().toISOString().substr(0, 19), this.logPrefix, ...props)
}
error(...props) {
console.error(new Date().toISOString().substr(0, 19), this.logPrefix, ...props)
}
}
```
Теперь подключим биржу
----------------------
```
yarn add node-binance-api
```
Добавим класс BaseApiService. Сделаем в нем инициализацию Binance SDK, а также применим сервис LoggerService. Учитывая мой опыт с Binance могу сразу сказать, что в зависимости от торговой пары мы должны слать цену и обьем с разным количеством знаков после запятой. Все эти настройки для каждой пары можно взять, сделав запрос `futuresExchangeInfo()`. И написать методы для получения количества знаков после запятой для цены `getAssetPricePrecision` и объема `getAssetQuantityPrecision`.
```
class BaseApiService {
constructor({ client, secret }) {
const { log, error } = new Logger('BaseApiService')
this.log = log
this.error = error
this.api = new NodeBinanceApi().options({
APIKEY: client,
APISECRET: secret,
hedgeMode: true,
})
this.exchangeInfo = {}
}
async init() {
try {
this.exchangeInfo = await this.api.futuresExchangeInfo()
} catch (e) {
this.error('init error', e)
}
}
getAssetQuantityPrecision(symbol) {
const { symbols = [] } = this.exchangeInfo
const s = symbols.find(s => s.symbol === symbol) || { quantityPrecision: 3 }
return s.quantityPrecision
}
getAssetPricePrecision(symbol) {
const { symbols = [] } = this.exchangeInfo
const s = symbols.find(s => s.symbol === symbol) || { pricePrecision: 2 }
return s.pricePrecision
}
}
```
Дальше добавляем метод создания ордера, с учетом правильного количества знаков после запятой для цены и обьема:
```
async futuresOrder(side, symbol, qty, price, params={}) {
try {
qty = Number(qty).toFixed(this.getAssetQuantityPrecision(symbol))
price = Number(price).toFixed(this.getAssetPricePrecision(symbol))
if (!params.type) {
params.type = ORDER.TYPE.MARKET
}
const res = await this.api.futuresOrder(side, symbol, qty, price || false, params)
this.log('futuresOrder', res)
return res
} catch (e) {
console.log('futuresOrder error', e)
}
}
```
Теперь бот умеет создавать ордера. Научим его слушать события из биржы для того, чтоб он мог отлавливать изменения статуса ордеров. Для этого создадим класс TradeService.
```
class TradeService {
constructor({client, secret}) {
const { log, error } = new LoggerService('TradeService')
this.log = log
this.error = error
this.api = new NodeBinanceApi().options({
APIKEY: client,
APISECRET: secret,
hedgeMode: true,
})
this.events = new EventEmitter()
}
marginCallCallback = (data) => this.log('marginCallCallback', data)
accountUpdateCallback = (data) => this.log('accountUpdateCallback', data)
orderUpdateCallback = (data) => this.emit(data)
subscribedCallback = (data) => this.log('subscribedCallback', data)
accountConfigUpdateCallback = (data) => this.log('accountConfigUpdateCallback', data)
startListening() {
this.api.websockets.userFutureData(
this.marginCallCallback,
this.accountUpdateCallback,
this.orderUpdateCallback,
this.subscribedCallback,
this.accountConfigUpdateCallback,
)
}
subscribe(cb) {
this.events.on('trade', cb)
}
emit = (data) => {
this.events.emit('trade', data)
}
}
```
При помощи метода из SDK `this.api.websockets.userFutureData` подписываемся на события из биржы. Самой главный колбек для нас `this.orderUpdateCallback` . Он вызывается каждый раз когда меняется статус у ордера. Ловим это событие и прокидываем через `EventEmitter` тому, кто на это событие подписался, используя метод `subscribe`.
Перейдем к базе данных
----------------------
Для чего она нужна? В базе будем хранить все ордера, а также всю историю торговли бота. Пользователей с их ключами к бирже и балансами. В последствии сможем считать сколько бот принес прибыли/убытка. Тут останавливаться долго не буду. Подключаю sequlize.
```
yarn add sequelize-cli -D
yarn add sequelize
npx sequelize-cli init
```
Добавим docker-compose.yml файл для локальной базы:
```
version: '3.1'
services:
db:
image: 'postgres:12'
restart: unless-stopped
volumes:
- ./volumes/postgresql/data:/var/lib/postgresql/data
environment:
POSTGRES_USER: root
POSTGRES_PASSWORD: example
POSTGRES_DB: bot
ports:
- 5432:5432
networks:
- postgres
networks:
postgres:
driver: bridge
```
А также добавляю миграции и модели. `User`, `Order`
Продолжение следует.
В следующей статье будем писать ядро, которое соединит все эти части и заставит бота торговать.
Продолжение [тут](https://habr.com/ru/post/567836/) | https://habr.com/ru/post/562496/ | null | ru | null |
# Запись и модификация звука в браузере
Недавно решил for fun сделать сайт, на котором будет происходить запись и модификация звука. А ещё хотелось какой-нибудь соответствующей анимации. Как работать со звуком на С++ или C# я знаю, опыт есть, однако ни разу не делал этого в браузере.
Немного погуглив, выяснилось что не так уж и много возможностей записать звук. Самая широко распространенная — использование Flash. У меня нет опыта во Flash, к тому же весь UI и функционал я хотел сделать на JavaScript + HTML, поэтому нужно было как-то обойтись без Flash или с минимальным его участием. В итоге, я нашел [jQuery плагин jRecorder](http://www.sajithmr.me/jrecorder-jquery) для записи звука, который внутри себя в итоге использует Flash, а точнее ActionScript код. Но так как работа со звуком была обёрнута в JavaScript, то такой вариант мне подошел.
[](https://habrastorage.org/getpro/habr/post_images/031/f42/5ee/031f425ee017106eb402383e890f3388.jpg)
Моей задумкой было сделать так, чтобы человек говорил что-нибудь в микрофон, этот звук записывался, и потом воспроизводился уже немного искаженным. Для забавы, хотелось добавить туда ещё какую-нибудь простейшую анимацию. Но, я программист, а не дизайнер, поэтому рисовать Flash или HTML5 ролик совсем не моё. Решил выкрутится более простым спосбом — страничку сайта нарисовал сам, а вот в качестве анимации решил использовать gif. Нагуглил забавного Хомячка, который что-то жуёт, и пришла в голову мысль — пускай он молчит (слушая, как человек что-то говорит в микрофон), а потом «произносит» это. То есть, вырисовалась такая задачка:
— Запись звука
— Искажение звука
— Воспроизведение звука и включение анимации
Ну что ж, работа закипела. Сначала для тестов написал нехитрый JS-код, который переключает gif картинку на статическую картинку Хомячка:
```
function setPictureHamsterStop()
{
document.getElementById("switch").src = "2.png";
}
function setPictureHamsterSpeech()
{
document.getElementById("switch").src = "3.gif";
}
```
Далее было необходимо встроить код jRecorder в мою страницу, а именно, чтобы во время воспроизведения звука показывался Gif, а во время записи Png. jRecorder встраивает окно Flash в страницу и делает её невидимой.
В свою страничку надо вставить небольшой блок CSS сверху, а в основном body разместить скрипт инициализации с настройками:
```
$.jRecorder(
{
host : 'ваш_урл_куда_сохранять_записанный_файл_wav' ,
callback_started_recording: function(){callback_started(); },
callback_stopped_recording: function(){callback_stopped(); },
callback_activityLevel: function(level){callback_activityLevel(level); },
callback_activityTime: function(time){callback_activityTime(time); },
callback_finished_sending: function(time){ callback_finished_sending() },
swf_path : 'jRecorder.swf',
}
);
```
Сайт я решил выложить на бесплатном хостинге, для чего использовал свой Google Drive account. Как его использовать под хостинг на Хабре уже [писали](http://habrahabr.ru/post/160833/). Там куча ограничений, одно из них не позволяет
мне записывать php-скриптом файл на Google Drive извне. Поэтому сайт может быть только статическим. Но мне это не мешало, так как вся работа происходит «на клиенте».
Далее, я скопировал весь код JS из jReader и первым делом убрал из него обработчики callback-ов, которые мне не нужны. Основными для меня событиями были callback\_started, callback\_stopped, callback\_finished\_sending. Callback'и говорят сами за себя. Алгоритм прост:
— После начала записи приходит callback\_started, а мы ставим картинку в статику (Хомячок молчит и слушает)
— после остановки записи попадаем в callback\_stopped и делаем SendFile
— OnSendFinished показываем gif-анимацию, так как звук начинает воспроизводиться (это уже согласно логике самого jRecorder
Но тут проблема: когда начинать или останавливать запись? Мне не хотелось делать это простой кнопкой, пусть хомяк произносит слова только тогда, когда в микрофон действительно что-то говорили, а не шел простой шум или тишина.
Для этого я решил анализировать уровень звука с микрофона, на счастье, jRecorder бросает callback\_activityLevel, в котором передается уровень звука — level. Мне нужно было только придумать алгоритм. И я решил делать так:
— Методом подбора установил оптимальный уровень звука, который можно считать шумом (кстати, позже, покопавшись в ActionScript исходниках jRecorder оказалось, что в нем есть подобное значение и оно равно моему).
— Опять же методом подбора установил пороговую длину записи шума. То есть, завел простой счетчик, который каждый раз увеличивается на 1, если пришел шум. Если этот счетчик больше порогового значения — то останавливаем запись (незачем нам записывать и воспроизводить шум).
— Каждый раз при входе в обработчик callback\_activityLevel проверяем является ли данный уровень шумом: если да, то увеличиваем счетчик шумов на 1, а если нет — обнуляем этот счетчик (начнем считать заново).
— Дополнительно устанавливаем Boolean флажок, который ставится в true если за всю запись хотя бы раз был превышен порог шума. Это для того, чтобы не гонять «пустые» записи по сети — бережем траффик.
В итоге, если человек ничего не говорит долгое время и в микрофон не попадает никаких дополнительных шумов, то мы не воспроизводим ничего. В случае раговора (ну или шумов, что тоже бывает ) пишем 30 секунд речи,
либо если человек перестает говорить раньше, наш счетчик порога шума сам остановит запись. После остановки происходит воспроизведение звука:
```
var SILENCE_LEVEL = 5;
var PEAK_LEVEL = 10;
var MAX_SILENCE_TICKS = 50;
var MICROPHONE_AMPLIFY_LEVEL = 10;
var silenceCounter = 0;
var wasLevelPeak = 0;
var isRecording = 0;
function callback_started(){
// Устанавливаем картинку Хомячка статичной - он слушает и молчит.
setPictureHamsterStop();
silenceCounter = 0;
totalTime = 0;
wasLevelPeak = 0;
isRecording = 1;
}
function callback_stopped(){
silenceCounter = 0;
isRecording = 0;
if (wasLevelPeak) {
// Если было что-то кроме шума, отправляем файл со звуком на сервер.
// В моей реализации мне это нужно было только чтобы воспроизвести звук.
wasLevelPeak = 0;
$.jRecorder.sendData();
}
else {
$.jRecorder.record(30);
}
}
function callback_finished_sending(){
// Показываем GIF картинку, в которой Хомячок начинает говорить.
var timer = setTimeout('setPictureHamsterSpeech();', 2000);
var timer = setTimeout('$.jRecorder.record(5);', totalTime * 1000);
}
function callback_activityLevel(level){
// Проверяем уровень звука.
if (level > PEAK_LEVEL && isRecording)
{
wasLevelPeak = 1; // Да, есть что-то...
silenceCounter = 0;
}
// Считаем "условное" количество сэмплов с шумами.
if(level < SILENCE_LEVEL && isRecording)
{
silenceCounter = silenceCounter + 1;
}
// Если мы насчитали достаточное количество шумов - то останавливаем запись
// (просто чтобы обнулить её, позже она начнется снова).
if (silenceCounter == MAX_SILENCE_TICKS && isRecording)
{
silenceCounter = 0;
$.jRecorder.stop();
}
}
```
С Java-Script частью записи-воспроизведения разобрались. Теперь встала следующая задача — модификация звука. jRecorder поставляется с исходными кодами на Action Script, но его я не знаю, да и никогда толком с Flash не работал.
Но код ActionScript оказался очень нативно понятным, и я быстро разобрался с логикой записи-воспроизведения звука. Мне нужно было дописать код модификации звука, скомпилировать его в \*.swf файл, и подложить вместо существующего jRecorder.swf. Поставил Trial версию Flash, открыл проект AudioRecorderCS4.fla, погуглил код модификации звука, и на моё счастье прямо на [официальном сайте Adobe](http://help.adobe.com/en_US/ActionScript/3.0_ProgrammingAS3/WS1C0E1BE2-5322-4558-B7F9-73326C8F48EE.html) нашел примеры работы со звуком.
Во время записи с микрофона идут пачки сырых байт — сэмплов. В jRecorder написан обработчик звука, который срабатывая по SampleDataEvent добавлял новую пачку байт к общей «куче», чтобы
в итоге получился большой массив байт — записанного звука:
```
private function onSampleData(event:SampleDataEvent):void
{
_recordingEvent.time = getTimer() - _difference;
dispatchEvent( _recordingEvent );
// Вот тут добавляется новая пачка байт
while(event.data.bytesAvailable > 0)
_buffer.writeFloat(event.data.readFloat());
}
```
Чтобы сделать звук смешнее, нужно лишь пропустить немного байт, то есть при воспроизведении звук проиграется просто быстрее:
```
private function onSampleData(event:SampleDataEvent):void
{
_recordingEvent.time = getTimer() - _difference;
dispatchEvent( _recordingEvent );
/* Ускоряем звук */
event.data.position = 0;
while(event.data.bytesAvailable > 0)
{
_buffer.writeFloat(event.data.readFloat());
if (event.data.bytesAvailable > 0) // опять же, проверяем, что в потоке ещё что-то есть
{
_buffer.writeFloat(event.data.readFloat());
}
if (event.data.bytesAvailable > 0)
{
event.data.position += 2; // Ну подумаешь, пропустили чуть-чуть
}
}
}
```
Готово. Ctrl+Enter, компиляция, подмена jRecorder.swf, и получаем рабочий прототип. Немного криворукой графики: сам нарисовал ракету в космосе, «подогнал» gif картинки по размеру, чтобы хомячок «сидел» в ракете
(с помощью редактора [Online Image Editor](http://www.online-image-editor.com/))и выложил СИЕ на Google Drive hosting. Открываем сайт, Flash спрашивает разрешение на доступ к микрофону:
Если пользователь соглашается, то начинаются циклы записи-воспроизведения. В итоге, получилась несколько забавная поделка и плюс к опыту работы со звуком. Вот результат: [Space Hamster](https://googledrive.com/host/0B4Q3U97fHTqIVzhpb09XRTJ2enM/index.html).
Вполне может случиться, что в каком-то браузере это не заработает, если будут какие-то отзывы, попробую собрать статистику по этому вопросу. | https://habr.com/ru/post/172299/ | null | ru | null |
# Извлечение аудиоданных из wav-файла на UWP
Сегодня мы представляем материал от наших давних партнеров, компании Music Paradise, которые, как вы помните, уже делились с Хабром секретами создания музыкальных приложений в нашей совместной статье «[Внедрение социальных сервисов в неигровое приложение](https://habrahabr.ru/company/everydaytools/blog/319290/)». На этот раз специалисты из команды расскажут о специфике реализации базовых функций утилиты Audio Editor, изначально написанной для [iOS](http://go.everydaytools.mobi/9AICaU) и [Mac](http://go.everydaytools.mobi/ysPxlb) устройств, на новой платформе — [Windows](http://go.everydaytools.mobi/dfyFaN) — и о том методе, который они применяли при адаптации.
«В этой статье мы рассмотрим один из самых доступных способов получения аудиоданных из файла. Извлечение аудиоданных является краеугольным камнем для всех разработчиков, которые делают первые шаги в работе со звуком, однако внимания ей уделяется на удивление мало. Проблема ощущается особенно остро при попытках найти готовые решения или инструкции для UWP в интернете: в большинстве случаев ответа не получаешь вообще или же приходится довольствоваться устаревшими решениями. Между тем, при работе со звуком извлечение данных имеет значимый смысл, давая разработчику возможность редактировать данные: копировать, добавлять, изменять, путем наложения эффектов, визуализировать их на экране пользователя. Именно о визуализации сегодня и пойдет речь. Несмотря на существование специальных библиотек для работы с аудиоданными в галерее NuGet, мы построим логику приложения на самостоятельной обработке байтов аудиофайла. Таким образом, в процессе мы узнаем больше о структуре wav-файла и убедимся на практике, что работа с аудио данными — это не так уж сложно.
Итак, чтобы достигнуть поставленной цели, а именно построить графическое отображение аудиоволны, для начала мы должны извлечь данные. Процесс будет описываться на примере wav-файла, так как это один из наиболее удобных аудиоформатов для работы.
Однако мы с вами понимаем, что мир цифрового аудио слишком велик, чтобы можно было свести всё к работе с одним-единственным форматом. Поэтому сразу оговорим дополнительный шаг: в случае, если нам достался файл любого другого формата, мы прежде всего конвертируем его в wav. Не пугайтесь, этот процесс обычно не занимает у устройства много времени.
Реализуем простейший интерфейс, добавив две кнопки в MainPage.xaml:
```
```
Опишем алгоритм, который будет выполняться по клику на кнопку «Choose Audio File». Для этого добавим в MainPage.xaml.cs следующие строки:
```
private StorageFile currentFile;
private PlottingGraphImg imgFile;
private async void ChooseFile_Click(object sender, RoutedEventArgs e)
{
var picker = new Windows.Storage.Pickers.FileOpenPicker();
picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.MusicLibrary;
picker.FileTypeFilter.Add(".mp4");
picker.FileTypeFilter.Add(".mp3");
picker.FileTypeFilter.Add(".wav");
StorageFile file = await picker.PickSingleFileAsync();
await ConvertToWaveFile(file);
}
public async Task ConvertToWaveFile(StorageFile sourceFile)
{
MediaTranscoder transcoder = new MediaTranscoder();
MediaEncodingProfile profile = MediaEncodingProfile.CreateWav(AudioEncodingQuality.Medium);
CancellationTokenSource cts = new CancellationTokenSource();
//Create temporary file in temporary folder
string fileName = String.Format("TempFile_{0}.wav", Guid.NewGuid());
StorageFile temporaryFile = await ApplicationData.Current.TemporaryFolder.CreateFileAsync(fileName);
currentFile = temporaryFile;
if (sourceFile == null || temporaryFile == null)
{
return;
}
try
{
var preparedTranscodeResult = await transcoder.PrepareFileTranscodeAsync(sourceFile, temporaryFile, profile);
if (preparedTranscodeResult.CanTranscode)
{
var progress = new Progress((percent) => { Debug.WriteLine("Converting file: " + percent + "%"); });
await preparedTranscodeResult.TranscodeAsync().AsTask(cts.Token, progress);
}
else
{
Debug.WriteLine("Error: Convert fail");
}
}
catch
{
Debug.WriteLine("Error: Exception in ConvertToWaveFile");
}
}
```
*Примечание*: подобный метод можно применять и для видеоформатов, что тоже порой очень полезно.
Теперь, когда пользовательский wav-file стал доступен, необходимо получить из него аудиоданные, ради которых мы всё это и затеяли. Чтобы это сделать, придется вникнуть в структуру файла. Сильно вдаваться в теорию мы не видим смысла — подобной информации в интернете более чем достаточно, вы всегда можете почерпнуть интересующие вас сведения там. Мы же ограничимся тем, что обрисуем общую структуру файла, чтобы прояснить логику дальнейшей реализации.
Итак, структура несжатого аудио файла в формате импульсно-кодовой модуляции (PCM) выглядит следующим образом:
Теперь перейдем собственно к алгоритму получения аудиоданных. В работе мы будем опираться на [следующий ресурс](https://msdn.microsoft.com/en-us/library/ff827591.aspx).
Опишем класс с символичным названием «WavFile»:
```
public class WavFile
{
public string PathAudioFile { get; }
private const int ticksInSecond = 10000000;
private TimeSpan duration;
public TimeSpan Duration { get { return duration; } }
#region AudioData
private List floatAudioBuffer = new List();
#endregion
public WavFile(string \_path)
{
PathAudioFile = \_path;
ReadWavFile(\_path);
}
public float[] GetFloatBuffer()
{
return floatAudioBuffer.ToArray();
}
private void ReadWavFile(string filename)
{
try
{
using (FileStream fileStream = File.Open(filename, FileMode.Open))
{
BinaryReader reader = new BinaryReader(fileStream);
// RIFF
int chunkID = reader.ReadInt32();
int fileSize = reader.ReadInt32();
int riffType = reader.ReadInt32();
// Format
int fmtID;
long \_position = reader.BaseStream.Position;
while (\_position != reader.BaseStream.Length - 1)
{
reader.BaseStream.Position = \_position;
int \_fmtId = reader.ReadInt32();
if (\_fmtId == 544501094)
{
fmtID = \_fmtId;
break;
}
\_position++;
}
int fmtSize = reader.ReadInt32();
int fmtCode = reader.ReadInt16();
int channels = reader.ReadInt16();
int sampleRate = reader.ReadInt32();
int byteRate = reader.ReadInt32();
int fmtBlockAlign = reader.ReadInt16();
int bitDepth = reader.ReadInt16();
if (fmtSize == 18)
{
int fmtExtraSize = reader.ReadInt16();
reader.ReadBytes(fmtExtraSize);
}
int dataID = reader.ReadInt32();
int dataSize = reader.ReadInt32();
byte[] byteArray = reader.ReadBytes(dataSize);
int bytesInSample = bitDepth / 8;
int sampleAmount = dataSize / bytesInSample;
float[] tempArray = null;
switch (bitDepth)
{
case 16:
Int16[] int16Array = new Int16[sampleAmount];
System.Buffer.BlockCopy(byteArray, 0, int16Array, 0, dataSize);
IEnumerable tempInt16 =
from i in int16Array
select i / (float)Int16.MaxValue;
tempArray = tempInt16.ToArray();
break;
default:
return;
}
floatAudioBuffer.AddRange(tempArray);
duration = DeterminateDurationTrack(channels, sampleRate);
}
}
catch
{
Debug.WriteLine("File error");
return;
}
}
private TimeSpan DeterminateDurationTrack(int channels, int sampleRate)
{
long \_duration = (long)(((double)floatAudioBuffer.Count / sampleRate / channels) \* ticksInSecond);
return TimeSpan.FromTicks(\_duration);
}
}
```
*Примечание*: подобный способ даст нам возможность не только визуализировать аудиоданные, но и редактировать их. Кстати, обратный процесс сохранения данных организовать несложно, для этого достаточно снова использовать класс FileStream и последовательно записать полученные данные в файл.
*Примечание*: вы уже скорее всего обратили внимание, что при описании алгоритма мы отступили от вышеописанной структуры wav-файла. Это связано с тем, что файл, полученный путем конвертирования, имеет несколько отличную структуру. В частности, добавляется секция, не имеющая для нас большого значения — в ней хранится id, размер и информация о формате, после чего следует последовательность из нулевых байтов. Пропуск ненужной секции происходит путем перебора байтов в цикле и сравнения их со значением 544501094 (это необходимое значение поля Subchunk1Id, с которого и начинается секция Format). Подобный перебор необходим и по той причине, что вышеозначенная структура является примерной, но не обязательной и от нее порой отступают.
Наконец, получив данные, мы можем приступить к финальному шагу — построению графика. Тут существует несколько способов, приведем два самых распространенных:
1. Построение изображения при помощи геометрических фигур.
2. Создание точечных рисунков.
Остановимся на них подробнее. Невзирая на ресурсозатратность, первый способ построения изображения пользуется популярностью в Сети при демонстрации тех или иных примеров работы с аудиодорожками. Он, возможно, и неплох для построения небольших графиков, но становится нерациональным, когда речь идет о выводе на экран изображения волны всей аудиодорожки целиком. Поэтому такой вариант нам не подходит.
Второй способ менее ресурсозатратен и сопряжен с использованием небезопасного кода. По результату работы мы получим изображение, которое сможем использовать в своем приложении или, к примеру, сохранить на жесткий диск для дальнейшего применения.
Инструкция о том, как работать с точечным изображением в UWP, доступна по [ссылке](https://docs.microsoft.com/ru-ru/windows/uwp/audio-video-camera/imaging). Описывая свою логику построения изображения аудиофайла, мы будем во многом основываться на этом материале.
Добавим в проект структуру и класс, описанные выше:
```
public struct GraphicalWavePlot
{
private float minValue;
private float maxValue;
private float peakValue;
public GraphicalWavePlot(
float minValue,
float maxValue,
float peakValue
)
{
this.minValue = minValue;
this.maxValue = maxValue;
this.peakValue = peakValue;
}
public bool CheckArea(int pos, int heightImg)
{
double Oh = heightImg / 2;
double y0 = Oh - Math.Abs(minValue) * Oh / peakValue;
double y1 = Oh + maxValue * Oh / peakValue;
return (pos > y0 && pos < y1);
}
}
public class PlottingGraphImg
{
private List waveSamples = new List();
private SoftwareBitmap softwareBitmap;
private WavFile wavFile;
private Color backgroundColor = Color.FromArgb(0, 0, 0, 0);
public Color BackgroundColor
{
get { return backgroundColor; }
set { backgroundColor = value; }
}
private Color foregroundColor = Color.FromArgb(255, 255, 255, 255);
public Color ForegroundColor
{
get { return foregroundColor; }
set { foregroundColor = value; }
}
private int image\_width;
public int ImageWidth
{
get { return image\_width; }
set { image\_width = value; }
}
private int image\_height;
public int ImageHeight
{
get { return image\_height; }
set { image\_height = value; }
}
public PlottingGraphImg(WavFile \_wavFile, int \_image\_width, int \_image\_height)
{
this.wavFile = \_wavFile;
this.image\_width = \_image\_width;
this.image\_height = \_image\_height;
BuildImage();
CreateGraphicFile();
}
private void BuildImage()
{
int xPos = 2;
int interval = 1;
var yScale = ImageHeight;
float[] readBuffer = wavFile.GetFloatBuffer();
int samplesPerPixel = readBuffer.Length / ImageWidth;
float negativeLimit = readBuffer.Take(readBuffer.Length).Min();
float positiveLimit = readBuffer.Take(readBuffer.Length).Max();
float peakValue = (positiveLimit > negativeLimit) ? (positiveLimit) : (negativeLimit);
peakValue \*= 1.2f;
for (int i = 0; i < readBuffer.Length; i += samplesPerPixel, xPos += interval)
{
float[] partBuffer = new float[samplesPerPixel];
int lengthPartBuffer = ((i + samplesPerPixel) > readBuffer.Length) ? (readBuffer.Length - i) : (samplesPerPixel);
Array.Copy(readBuffer, i, partBuffer, 0, lengthPartBuffer);
var min = partBuffer.Take(samplesPerPixel).Min();
var max = partBuffer.Take(samplesPerPixel).Max();
waveSamples.Add(new GraphicalWavePlot(minValue: min, maxValue: max, peakValue: peakValue));
}
}
[ComImport]
[Guid("5B0D3235-4DBA-4D44-865E-8F1D0E4FD04D")]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
unsafe interface IMemoryBufferByteAccess
{
void GetBuffer(out byte\* buffer, out uint capacity);
}
public unsafe void CreateGraphicFile()
{
softwareBitmap = new SoftwareBitmap(BitmapPixelFormat.Bgra8, ImageWidth, ImageHeight);
using (BitmapBuffer buffer = softwareBitmap.LockBuffer(BitmapBufferAccessMode.Write))
{
using (var reference = buffer.CreateReference())
{
byte\* dataInBytes;
uint capacity;
((IMemoryBufferByteAccess)reference).GetBuffer(out dataInBytes, out capacity);
// Fill-in the BGRA plane
BitmapPlaneDescription bufferLayout = buffer.GetPlaneDescription(0);
for (int i = 0; i < bufferLayout.Width; i++)
{
for (int j = 0; j < bufferLayout.Height; j++)
{
Color tempColor = waveSamples[i].CheckArea(j, ImageHeight) ? ForegroundColor : BackgroundColor;
//Blue
dataInBytes[bufferLayout.StartIndex + bufferLayout.Stride \* j + 4 \* i + 0] = (byte)tempColor.B;
//Green
dataInBytes[bufferLayout.StartIndex + bufferLayout.Stride \* j + 4 \* i + 1] = (byte)tempColor.G;
//Red
dataInBytes[bufferLayout.StartIndex + bufferLayout.Stride \* j + 4 \* i + 2] = (byte)tempColor.R;
//Alpha
dataInBytes[bufferLayout.StartIndex + bufferLayout.Stride \* j + 4 \* i + 3] = (byte)tempColor.A;
}
}
}
}
}
public async Task SaveGraphicFile(StorageFile outputFile)
{
using (IRandomAccessStream stream = await outputFile.OpenAsync(FileAccessMode.ReadWrite))
{
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, stream);
encoder.SetSoftwareBitmap(softwareBitmap);
encoder.BitmapTransform.InterpolationMode = BitmapInterpolationMode.Fant;
encoder.IsThumbnailGenerated = true;
try
{
await encoder.FlushAsync();
}
catch (Exception err)
{
switch (err.HResult)
{
case unchecked((int)0x88982F81): //WINCODEC\_ERR\_UNSUPPORTEDOPERATION
// If the encoder does not support writing a thumbnail, then try again
// but disable thumbnail generation.
encoder.IsThumbnailGenerated = false;
break;
default:
throw err;
}
}
if (encoder.IsThumbnailGenerated == false)
{
await encoder.FlushAsync();
}
}
}
}
```
*Примечание*: не забудьте в свойствах проекта разрешить использование небезопасного кода (правой кнопкой мыши кликнуть по проекту, в появившемся консольном меню выбрать Properties, далее в открывшемся окне активировать вкладку Build и в поле Allow unsafe code поставить галочку, см. ниже).
Итак, мы рассмотрели схему получения аудиоданных и построения графика. Теперь осталось только вызвать её из класса MainPage. Для этого нам понадобится кнопка «Build And Save Image File», по клику на которую и будет запускаться прописанный нами алгоритм работы. Чтобы её реализовать, к строкам, введённым в MainPage.xaml.cs ранее, добавим метод, представленный выше:
```
private async void BuildAndSaveImageFile_Click(object sender, RoutedEventArgs e)
{
WavFile wavFile = new WavFile(currentFile.Path.ToString());
imgFile = new PlottingGraphImg(wavFile, 1000, 100);
FileSavePicker fileSavePicker = new FileSavePicker();
fileSavePicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
fileSavePicker.FileTypeChoices.Add("JPEG files", new List() { ".jpg" });
fileSavePicker.SuggestedFileName = "image";
var outputFile = await fileSavePicker.PickSaveFileAsync();
if (outputFile == null)
{
// The user cancelled the picking operation
return;
}
await imgFile.SaveGraphicFile(outputFile);
}
```
Проверим проект на наличие ошибок и не добавленных библиотек, а затем запустим его. По результату работы получаем вот такое изображение для выбранного аудиофайла».
 | https://habr.com/ru/post/325828/ | null | ru | null |
# Небольшой тест скорости QCoreApplication
Для надежности и безопасности, часто имеет смысл разделить функционал приложения на множество небольших исполняемых файлов (демонов), вместо того, чтобы поддерживать крупное и монолитное приложение.
В своё время, Qt4 была разделена на несколько модулей, что в частности позволило создавать приложения, не требующих графического интерфейса. Благодаря сильной фокусировке на архитектуре встраиваемых систем и нескольким здравомыслящим решениям в области архитектуры, Qt5 вывела данный подход на новый уровень.
Давайте посмотрим на простую функцию:
```
QCoreApplication app(argc, argv);
QTimer::singleShot(3000, &app, SLOT(quit()));
return app.exec();
```
Это Qt-приложение, не имеющее графического интерфейса. Оно работает 3 секунды и затем завершается.
На моей Kubuntu 12.04 со стандартным ядром и Qt 4.8.1 Valgrind показывает пиковое использование кучи в 102 кб, в то время как Callgrind сообщает о выполнении 1.9 (\*) миллиона инструкций процессора.
Давайте посмотрим на цифры полученные на сегодняшней сборке Qt 5: Valgrind сообщает 4,9 Кб выделения памяти в куче, а Callgrind сообщает примерно о 114 000 инструкций процессора.
Это означает, что Qt 5 использует примерно в 20 раз меньше памяти и примерно в 16 раз меньше инструкций процессора в конструкторе QCoreApplication и на выполнение Event-loop.
Есть несколько причин для этого. В частности, Qt 5 предполагает, что все строки по умолчанию имеют Unicode-кодировку, так что инициализация преобразователя кодировок текста происходит только при появлении первой не-Unicode строки. Хотя в Qt 5 значительно улучшилась производительность загрузки плагинов, они просто не могут загружаться ещё быстрее.
На скорости сказались также и другие улучшения, к примеру внедрение поддержки C++11 в Qt5 позволило создавать Unicode-строки, не требующие выделения памяти в куче.
В общем, попробуйте весёлого написания своих демонов на Qt и если у вас появятся какие-либо идеи по оптимизации кода — милости просим в [Qt Codereview](https://codereview.qt-project.org/).
(\*) Предупреждение: Количество инструкций не показывает, как быстр код, а только количество инструкций фактически обработанных процессором. Обратите внимание, что во всех случаях я измерил производительность только функции main(), не обращая внимания на издержки загрузки разделяемых библиотек, так что приложение может быть дополнительно оптимизировано при помощи предварительного связывания или прямым форком от уже работающего процесса.
**От переводчика:** если подобные небольшие переводы приживутся и я как переводчик в ваших глазах не полный мудак, то постараюсь продолжать переводить заметки из блога Qt Labs. Спасибо =) | https://habr.com/ru/post/149580/ | null | ru | null |
# MVI и State Machine — объединяем концепции. Визуализация и анализ диаграммы состояний в Android и KMM проектах
Чтобы проще было развивать и поддерживать код продукта, сложную логику можно разбить на конечное множество состояний и описать правила переходов между ними.
В итоге мы получаем конечный автомат.
Часть бизнес-логики, описывающая смену состояний в MVI-архитектуре, может быть реализована в виде конечного автомата. Это даст возможность представить вашу логику в виде графа переходов для последующей визуализации и анализа.
Мы написали и выложили в опенсорс MVI-библиотеку на Kotlin — **[VisualFSM](https://github.com/Kontur-Mobile/VisualFSM)**, которая умеет по исходному коду строить визуализацию вашей системы, что позволит быстрее понимать сложные бизнес-процессы, упрощать поиск ошибок, добавлять новую функциональность и проводить рефакторинг.
Под катом я расскажу подробнее о нашем подходе, о том, как устроена библиотека, и как начать ее использовать.
**MVI и FSM**
-------------
**MVI (Model-View-Intent)** — архитектурный паттерн, который следует подходу "однонаправленный поток данных" (unidirectional data flow). Данные передаются от Model к View в одном направлении.
В VisualFSM Intent реализуется в виде действия (*Action*), в котором описываются возможные переходы состояний (*Transition*).
**FSM (Finite-state machine, конечный автомат)** — абстрактная сущность, которая может находиться только в одном из конечного количества состояний в определённый момент. Она может переходить из одного состояния в другое в ответ на входные данные.
Входной алфавит FSM — это объекты действий (*Action*). Выходным алфавитом являются объекты состояний (*State*). В каждый момент времени FSM находится в одном из конечного множества состояний (*State*).
MVI-архитектура хорошо сочетается с абстракцией FSM, в MVI у модели один вход и один выход, так же как в FSM. Если соединить выход View со входом FSM и наоборот то можно объединить две концепции, сделать это удобно позволяет библиотека VisualFSM.
**Плюсы VisualFSM**
-------------------
### **Один набор моделей**
Один набор классов `Action` и `State` используется для реализации MVI и описания FSM.
### **Построение по исходному коду**
Анализ исходного кода и построение графа выполняется с помощью рефлексии и реализован отдельным модулем, что даёт возможность подключить его только к тестовой среде.
Не требуется написания отдельных конфигураторов для FSM, достаточно добавлять новые классы State и Action – они становятся частью графа состояний и переходов FSM.
### **Визуализация диаграммы состояний**
Визуализация позволяет быстрее понимать сложные бизнес-процессы, упрощает поиск ошибок, помогает добавлять новую функциональность и проводить рефакторинг.
Если нужно добавить или убрать дополнительный диалог или экран, то, смотря на схему, проще понять, какие переходы и состояния нужно изменить.
Кроме того, глядя на схему, можно судить об оптимальности схемы, планировать объединение или наоборот выделять части в отдельные FSM.
В тестировании — полная схема состояний и переходов помогает тестировщику описать сценарии проверки.
### **Анализ диаграммы состояний**
Тестовые инструменты дают возможность выполнять такие распространенные проверки, как проверка на достижимость всех состояний и проверка множества терминальных состояний (для выявления незапланированных тупиковых состояний).
Также можно получить граф в виде списка ребер или словаря смежности для реализации прочих проверок в unit-тестах.
Сопоставив полный граф переходов и граф фактических переходов, выполненных на CI в процессе прохождения функциональных тестов, можно выявить переходы и состояния, не покрытые автотестами. Подробнее о том, как мы выполняем такой анализ, расскажем в отдельной статье. Чтобы не пропустить, подписывайтесь на [@visualfsm в Telegram](https://t.me/visualfsm).
Запись фактических переходов во время выполнения Ui тестов можно произвести в файл с помощью реализации TransitionCallbacks интерфейса.
### **Отсутствие side-effects**
В библиотеке нет SingleEvent шины, все transform функции чистые. Благодаря этому нельзя отправить или обработать Event, не привязанный к текущему состоянию.
Подробнее про недостатки SingleEvents можно почитать в статье Android DevRel Manuel Vivo: [ViewModel: One-off event antipatterns](https://medium.com/androiddevelopers/viewmodel-one-off-event-antipatterns-16a1da869b95)
Если необходимо отобразить тост, snackbar или диалог, это рекомендуется сделать через изменение состояния (см. Login.snackBarMessage в [примере](https://github.com/Kontur-Mobile/VisualFSM-Sample-Android/blob/main/app/src/main/java/ru/kontur/mobile/visualfsm/sample_android/feature/auth/fsm/AuthFSMState.kt)).
### **Концепция AsyncWorker**
`AsyncWorker` запускает асинхронный запрос или останавливает его, если ему по подписке придёт соответствующий `State`. Как только запрос завершится успешно или с ошибкой, результат необходимо передать в FSM, вызвав `Action`, и в FSM будет установлен новый `State`.
Асинхронная работа может быть представлена отдельными состояниями – благодаря этому мы имеем единый набор состояний, которые выстраиваются в ориентированный граф. Объект AsyncWorker упрощает обработку состояний, в которых выполняется асинхронная работа.
Есть два способа описания состояния, в котором ведется асинхронная работа:
1. Отдельное состояние, обозначающее асинхронную работу (например, AsyncWorkState.Loading), каждое такое состояние видно на диаграмме состояний (рекомендуется, если есть цепочка асинхронных состояний)
2. Флаг асинхронной работы внутри конкретного состояния (state.loading)
**Как это работает? Базовые классы VisualFSM**
----------------------------------------------
### **State в VisualFSM**
`State` – интерфейс-метка для обозначения классов состояний.
Пример реализации `State` — [AuthFSMState](https://github.com/Kontur-Mobile/VisualFSM-Sample-Android/blob/main/app/src/main/java/ru/kontur/mobile/visualfsm/sample_android/feature/auth/fsm/AuthFSMState.kt).
### **Action в VisualFSM**
`Action` — базовый класс действия, является входным объектом для FSM и описывает правила переходов в другие состояния, используя классы `Transition`. В зависимости от текущего `State` у FSM и заданного предиката (функции `predicate`) конструируется `State`, в который нужно перейти.
Пример реализации `Action` — [actions](https://github.com/Kontur-Mobile/VisualFSM-Sample-Android/tree/main/app/src/main/java/ru/kontur/mobile/visualfsm/sample_android/feature/auth/fsm/actions).
### **Transition в VisualFSM**
`Transition` — базовый класс перехода, реализуется как inner class в `Action`. Для
каждого `Transition` нужно указать два generic параметра :
* FROM — `State`, из которого происходит переход.
* TO — `State`, в котором будет находиться FSM после отработки `transform`.
Классам наследникам `Transition` необходимо реализовать функцию `transform`, а при наличии ветвления переопределить функцию `predicate`.
#### **Функции predicate и transform у Transition**
* `predicate` описывает условие выбора `Transition` на основе входных данных (переданных в конструктор `Action`), является одним из условий выбора `Transition`. Первым условием является совпадение текущего состояния со стартовым для `Transition`, указанным в generic. Если нет нескольких `Transition` с совпадающим стартовым `State`, `predicate` можно не переопределять.
* `transform` конструирует новое состояние для выполнения перехода.
### **AsyncWorker в VisualFSM**
`AsyncWorker` управляет запуском и остановкой асинхронной работы.
Подробнее о конфигурации `AsyncWorker` и доступных стратегий запуска и остановки операций в [документации](https://github.com/Kontur-Mobile/VisualFSM/blob/main/docs/ru/README-RU.md#asyncworker-%D0%B2-visualfsm).
Пример реализации `AsyncWorker` — [AuthFSMAsyncWorker](https://github.com/Kontur-Mobile/VisualFSM-Sample-Android/blob/main/app/src/main/java/ru/kontur/mobile/visualfsm/sample_android/feature/auth/fsm/AuthFSMAsyncWorker.kt).
### **Feature в VisualFSM**
`Feature` — фасад к FSM, предоставляет подписку на `State` и принимает `Action` для обработки.
```
@GenerateTransitionsFactory
class AuthFeature(initialState: AuthFSMState) : Feature(
initialState = initialState,
asyncWorker = AuthFSMAsyncWorker(AuthInteractor()), // Используйте DI
transitionsFactory = provideTransitionsFactory()
)
val authFeature = AuthFeature(
initialState = AuthFSMState.Login("", "")
)
// Подписка на состояния в Feature
authFeature.observeState().collect { state -> }
// Подписка на состояния в FeatureRx
authFeature.observeState().subscribe { state -> }
// Выполнение Action
authFeature.proceed(Authenticate("", ""))
```
Пример реализации `Feature` — [AuthFeature](https://github.com/Kontur-Mobile/VisualFSM-Sample-Android/blob/main/app/src/main/java/ru/kontur/mobile/visualfsm/sample_android/feature/auth/fsm/AuthFeature.kt).
### **TransitionCallbacks в VisualFSM**
`TransitionCallbacks` предоставляет функции обратного вызова для сторонней логики. Их удобно использовать для логгирования, записи бизнес метрик или отладки:
* `fun onActionLaunched(...)` — `Action` запускается.
* `fun onTransitionSelected(...)` — `Transition` выбран.
* `fun onNewStateReduced(...)` — `State` был создан.
* `fun onNoTransitionError(...)` — нет доступных `Transition` для перехода.
* `fun onMultipleTransitionError(...)` — доступно несколько `Transition` для перехода.
### **Инструменты VisualFSM**
* `VisualFSM.generateDigraph(...): String` — сгенерировать граф в DOT формате для визуализации в Graphviz, используйте аргумент `useTransitionName` для подстановки имени `Transition` или `Action` класса в качестве имени ребра или аннотацию `@Edge("name")` для `Transition` класса, чтобы установить произвольное имя ребра.
* `VisualFSM.getUnreachableStates(...): List>` — получить список всех недостижимых состояний от начального состояния.
* `VisualFSM.getFinalStates(...): List>` — получить список всех терминальных состояний.
* `VisualFSM.getEdgeListGraph(...): List, KClass, String>>` — получить список ребер.
* `VisualFSM.getAdjacencyMap(...): Map, List>>` — получить словарь смежности.
Пример использования инструментов — [AuthFSMTests](https://github.com/Kontur-Mobile/VisualFSM-Sample-Android/blob/main/app/src/test/java/ru/kontur/mobile/visualfsm/sample_android/AuthFSMTests.kt).
### **Кодогенерация**
Для сокращения шаблонного кода в реализациях `Action` классов мы используем KSP кодогенерацию. Генерируемым классом является `TransitionsFactory` для FSM, в котором инициализируются списки переходов для каждого `Action`.
**Подходы в работе с состоянием при использовании VisualFSM**
-------------------------------------------------------------
* FSM экрана — этот подход удобен для реализации сложных экранов, изменяющих свое содержимое в зависимости от состояния.
* FSM функционального блока — хорошим примером являются сквозные FSM, работающие независимо от конкретного экрана, но при этом данные состояний необходимо отображать в разных частях приложения.
* Глобальная FSM — все приложение можно описать в виде одной большой FSM. Такой подход можно использовать для небольших приложений, так как в процессе разрастания функциональности рано или поздно захочется выделять отдельные процессы в собственные FSM, иначе диаграмма состояний постепенно становится все менее читаема и между состояниями приходится предавать много данных.
* Комбинации подходов — можно иметь одну глобальную FSM, отвечающую, например, за навигацию в приложении, несколько FSM функциональных блоков и несколько FSM сложных экранов.
**Восстановление состояния после пересоздания процесса или Activity**
---------------------------------------------------------------------
Для возобновления работы FSM с определенного состояния его необходимо передать в конструктор `Feature`.
Если вы используете DI, то модуль, содержащий объекты FSM, должен инициализироваться после вызова `onCreate` `Activity` или `Fragment`, когда становится доступным `savedInstanceState` `Bundle`, в котором было сохранено состояние.
Объект `State` при этом должен реализовать интерфейс `Parcelable` и быть передан в `Bundle` метода `onSaveInstanceState`.
Пример Koin DI модуля, зависимого от сохраненного состояния — [Modules.kt](https://github.com/Kontur-Mobile/VisualFSM-Sample-Android/blob/main/app/src/main/java/ru/kontur/mobile/visualfsm/sample_android/feature/auth/di/Modules.kt).
**Примеры использования**
-------------------------
[Android приложение (Kotlin Coroutines, Jetpack Compose)](https://github.com/Kontur-Mobile/VisualFSM-Sample-Android)
[KMM (Android + iOS) приложение (Kotlin Coroutines, Jetpack Compose, SwiftUI)](https://github.com/Kontur-Mobile/VisualFSM-Sample-KMM)
**Как использовать в вашем проекте**
------------------------------------
Подключение библиотеки в проект описано в [Quickstart](https://github.com/Kontur-Mobile/VisualFSM/blob/main/docs/ru/Quickstart-RU.md)
**Текущее состояние и планы развития**
--------------------------------------
Библиотека используется в проекте Контур.Маркет Касса.
В разработке плагин для IntelliJ IDEA и Android Studio для визуализации диаграммы состояний в IDE и навигации по классам FSM из диаграммы.
Подробнее о проекте, в котором родилась идея библиотеки, и историю о первом неудачном подходе можно посмотреть в записи доклада Mobius Spring 2022: [Василий Рылов — MVI и State Machine — визуализация и анализ диаграммы состояний с помощью VisualFSM](https://www.youtube.com/watch?v=Z3k6-lVJ2WY).
О новых релизах мы рассказываем в [Telegram канале](https://t.me/visualfsm).
Обсудить вопрос применения библиотеки или проблему, с которой вы столкнулись, можно в [чате поддержки библиотеки](https://t.me/visualfsm_support). | https://habr.com/ru/post/691446/ | null | ru | null |
# Двухэтапная аутентификация в браузере с помощью USB-токена U2F
U2F — открытый протокол универсальной 2-факторной аутентификации, разработанный [FIDO Alliance](https://fidoalliance.org/).
В альянс входят компании Google, PayPal, Lenovo, MasterCard, Microsoft, NXP ,Visa и другие.
Протокол поддерживается браузером Chrome с версии 38. Работает из коробки без драйверов в Windows/MacOS/Linux.
На текущий момент поддерживается сервисами **Google, LastPass, Wordpress**.
В статье описывается опыт использования токена Yubikey NEO с поддержкой NFC и OpenPGP card, недостатки двухфакторной аутентификации по SMS.
**#### Почему двухэтапная аутентификация по SMS бывает опасна**
Сейчас очень популярна двухэтапная аутентификация при помощи SMS или звонка.
Безусловно, это удобно, и такая дополнительная проверка в большинстве случаев эффективна. Для защиты от автоматизированных атак, фишинга, подбора паролей, вирусов, восстановления утраченного доступа и прочего.
Но в случае, если ваша персона стала мишенью профессиональных мошенников, привязанный телефон может сыграть роковую роль. Чаще всего телефонный номер, к которому привязан аккаунт не является секретом, обычно это основной контактный номер. Почти все сервисы сообщают его первые или последние цифры любому желающему, если попытаться восстановить доступ к аккаунту. Поэтому выяснить номер связанный с аккаунтом несложно.
Узнать, на кого оформлен номер в России не составляет большого труда. Достаточно почитать [эксперимент](http://roem.ru/03-04-2015/191001/slishkom-mnogo-dayut) ребят из Roem.ru.
Получив персональные данные владельца номера, мошенники рисуют поддельную доверенность, водительские права или паспорт, и отправляются в ближайший филиал оператора сотовой связи.
Полномочия перевыпустить SIM-карту имеет любой рядовой сотрудник самого захудалого салона мобильной связи.
Забавно, что у большинства операторов в профиле абонента нет даже фотографии владельца номера, хотя паспорт они зачем-то ксерят. То есть достаточно нарисовать паспорт с совпадающими реквизитами и вклеить подходящую фотографию.
У операторов есть опция запрета перевыпуска SIM-карты по доверенности, однако это иллюзорная защита, потому как номера успешно перевыпускаются по поддельным водительским правам и паспортам.
**Как запретить действия по доверенности для Мегафон, Билайн, МТС****Мегафон:**
[moscow.megafon.ru/help/servic...sti.html#21123](http://moscow.megafon.ru/help/servic...sti.html#21123)
Для подключения услуги наберите на телефоне команду **\*105\*508#**.
Отключить услугу может только владелец номера при личном визите в салон «МегаФона» с документом, удостоверяющим личность.
**Билайн**
[moskva.beeline.ru/customers/help/safe-beeline/ugrozy-mobilnykh-moshennikov/zapret-deystvyi-po-doverenosti](http://moskva.beeline.ru/customers/help/safe-beeline/ugrozy-mobilnykh-moshennikov/zapret-deystvyi-po-doverenosti/)
Для установки запрета необходимо обратиться в один из офисов «Билайн» с паспортом или позвонив по номеру 0611.
**МТС**
При личном визите в офис попросить, чтобы в комментариях к номеру указали, что все действия имеет право совершать только владелец с паспортом.
В Украине ситуация еще хуже, так как большинство номеров анонимны.
У оператора Kyivstar для перевыпуска SIM-карты требуется показать чек последнего пополнения счета и назвать три номера, на которые совершались звонки.
Хорошие сервисы, например, многие банки, сохраняют вместе с телефонным номером еще и [IMSI](https://ru.wikipedia.org/wiki/IMSI) (International Mobile Subscriber Identity) — уникальный идентификатор SIM-карты. В случае, если IMSI изменился, то привязка номера считается аннулированной и процедуру привязки нужно пройти заново.
К сожалению, таких сервисов не очень много.
Проверить IMSI любого номера можно с помощью HLR-запроса [smsc.ru/testhlr](https://smsc.ru/testhlr/)
Рецепт для параноиков: у smsc.ru есть удобные библиотеки для Python, PHP, Perl, Ruby, Java, C#, Delphi, C++, позволяющие, в том числе, посылать HLR-запросы. Можно проверять IMSI своих номеров, например, два раза в сутки, и в случае его изменения бить тревогу. При самом дорогом тарифе один запрос стоит 0.2 рубля, выходит примерно 150 рублей в год за один номер. Через эту же библиотеку можно послать SMS с тревогой. Рекомендую ;)
Существуют и другие способы обхода подтверждения через мобильный телефон, такие как установка переадресации, перехват голосовой почты и т.д. Но их описание выходит за рамки данной статьи.
**Устрашающие истории пострадавших в результате перевыпуска SIM-карт**[www.banki.ru/forum/?PAGE\_NAME=message&FID=61&TID=188210](http://www.banki.ru/forum/?PAGE_NAME=message&FID=61&TID=188210)
[www.banki.ru/forum/?PAGE\_NAME=read&FID=61&TID=204319](http://www.banki.ru/forum/?PAGE_NAME=read&FID=61&TID=204319)
[www.banki.ru/forum/?PAGE\_NAME=message&FID=61&TID=195752](http://www.banki.ru/forum/?PAGE_NAME=message&FID=61&TID=195752)
[searchengines.guru/showthread.php?t=856465&page=3](http://searchengines.guru/showthread.php?t=856465&page=3)
#### U2F — FIDO Universal 2nd Factor
По задумке U2F аутентификатором выступает аппаратный модуль: USB-токен, SIM-карта или NFC брелок, который хранит ключи и самостоятельно выполняет криптографические операции. При этом ключи предустановлены при производстве и никогда не покидают токен.
Принцип работы таков:
1. Пользователь авторизуется на веб-сайте/в приложении с помощью логина-пароля
2. Сервер проверяет учетные данные и, если они верны, генерирует челендж для токена и отправляет его пользовательской программе, в данном случае, браузеру
3. Браузер передает челендж токену, который может затребовать на свое усмотрение действия от пользователя. В моем случае это прикосновение пальцем к контактной площадке. Но это может быть, например, ввод пинкода, биометрическая проверка или вообще отсутствие таковых
4. Токен возвращает программе ответ, который передается на сервер
5. Аутентификация выполнена
На текущий момент поддержка U2F есть в Google Chrome, начиная с 38 версии. Вероятно, в ближайшее время будет добавлена в FireFox.
Уже поддерживается для авторизации в аккаунтах Google и Lastpass, есть плагин для Wordpress, Django и библиотеки на разных языках.
Модули для Linux PAM, OpenSSH и прочего.
Таблица сервисов поддерживающих OTP/U2F авторизацию — [www.dongleauth.info](http://www.dongleauth.info/)
**Полезные ссылки**Примеры от Google [github.com/google/u2f-ref-code](https://github.com/google/u2f-ref-code)
Библиотека для PHP [github.com/Yubico/php-u2flib-server](https://github.com/Yubico/php-u2flib-server)
Библиотека для Ruby [github.com/castle/ruby-u2f](https://github.com/castle/ruby-u2f)
Демо на Python [github.com/Yubico/python-u2flib-server](https://github.com/Yubico/python-u2flib-server)
PAM-модуль [github.com/Yubico/pam-u2f](https://github.com/Yubico/pam-u2f)
#### Личный опыт использования токена Yubikey NEO
Самые продвинутые U2F устройства производит компания Yubico.
Дистрибьютор в России — [yubico.ru](http://yubico.ru)
Я купил самый навороченный на текущий момент брелок — Yubikey NEO.
Помимо U2F он умеет:
1. **OpenPGP smartcard** — определяется как ICCID ридер со вставленной OpenPGP картой версии 2.0
2. **NFC** — можно использовать со смартфонами и как ключ для СКУД. Может работать как карта Mifare Classic в режиме эмуляции
3. **OTP и TimeOTP** — определяется как hid клавиатура и по нажатию вводит одноразовый пароль. Time Based OTP через программный апплет (замена google authenticator)
4. **PIV smartcard** — ([Personal Identity Verification](https://en.wikipedia.org/wiki/FIPS_201)) американский государственный стандарт смарткарт
По дефолту устройство работает в режиме Yubico OTP (фирменный протокол одноразовых паролей), определяется только как HID-клавиатура и по нажатию на кнопку печатает одноразовые пароли на основе ID устройства.
Включить режим U2F нужно через фирменную утилиту, которая есть под Windows/Mac/Linux.
Я предпочел включить режимы U2F и ICCID для работы в качестве OpenPGP карты.
На этом все. U2F сразу работает, никакие драйвера устанавливать не требуется.
Проверить работу можно в демо-приложении [demo.yubico.com/u2f](https://demo.yubico.com/u2f)
Привязка токена к Google-аккаунту происходит крайне просто:
После привязки токена он становится вторым фактором по умолчанию, при этом нельзя отключить альтернативный способ: либо SMS, либо TOTP.
Альтернативным вторым фактором я выбрал TOTP. Я использую [программную реализацию TOTP](https://guides.agilebits.com/1password-mac/5/en/topic/setting-up-totps-time-based-one-time-passwords) через 1Password (то же, что и Google Authenticator, только на десктопе). Yubikey NEO тоже умеет TOTP, при этом ключ для генерации паролей сохраняется в токене и не может быть извлечен. Но так как пароли генерируются на основании времени, нужно держать запущенным программный апплет для передачи времени в токен, что мне не понравилось.
Я также бегло исследовал другие функции устройства.
**OpenPGP карта** сразу заработала с GnuPG 2.0.27 из пакета gpgtools.org.
**gpg --card-status**
```
Application ID ...: F3427001240104000006010230340000
Version ..........: 2.0
Manufacturer .....: Yubico
Serial number ....: 1023034
Name of cardholder: [not set]
Language prefs ...: [not set]
Sex ..............: unspecified
URL of public key : [not set]
Login data .......: [not set]
Signature PIN ....: forced
Key attributes ...: 2048R 2048R 2048R
Max. PIN lengths .: 127 127 127
PIN retry counter : 3 3 3
Signature counter : 0
Signature key ....: [none]
Encryption key....: [none]
Authentication key: [none]
General key info..: [none]
```
Карта версии 2.0, ключи только RSA и не длиннее 2048 бит.
Работа с картой возможна и через NFC, например, на Android с помощью <http://www.openkeychain.org/>. Прелесть такой связки в том, что все операции с закрытым ключом выполняются на карте, ключ никогда не покидает карту и не может быть извлечен из нее.
К сожалению, на днях была [найдена уязвимость](https://developers.yubico.com/ykneo-openpgp/SecurityAdvisory%202015-04-14.html) в реализации OpenPGP в Yubikey NEO, позволяющая обойти ввод пин-кода и выполнить операцию с приватным ключом. И, так как обновление прошивки на устройствах запрещено из соображений безопасности, исправить баг нет возможности. Компания Yubico обещает заменить кривые железки всем желающим.
У меня как раз оказалась уязвимая версия прошивки 1.0.8
**Эмуляция Mifare Classic** — самая непонятная для меня функция. При попытке общаться с ней, как с обычным Mifare Classic, карта ведет себя странно.
**вывод libnfc с попытками авторизоваться**
```
$ LIBNFC_LOG_LEVEL=3 ./readmifare1k.py -s 115200 -l /dev/tty.SLAB_USBtoUART
debug libnfc.config key: [allow_autoscan], value: [false]
debug libnfc.config key: [allow_intrusive_scan], value: [false]
debug libnfc.config key: [log_level], value: [1]
debug libnfc.config key: [device.name], value: [microBuilder.eu]
debug libnfc.config key: [device.connstring], value: [pn532_uart:/dev/tty.SLAB_USBtoUART]
debug libnfc.config Unable to open directory: /usr/local/etc/nfc/devices.d
debug libnfc.general log_level is set to 3
debug libnfc.general allow_autoscan is set to false
debug libnfc.general allow_intrusive_scan is set to false
debug libnfc.general 1 device(s) defined by user
debug libnfc.general #0 name: "microBuilder.eu", connstring: "pn532_uart:/dev/tty.SLAB_USBtoUART"
debug libnfc.driver.pn532_uart Attempt to open: /dev/tty.SLAB_USBtoUART at 115200 baud.
debug libnfc.bus.uart Serial port speed requested to be set to 115200 baud.
debug libnfc.chip.pn53x Diagnose
debug libnfc.chip.pn53x Timeout value: 500
debug libnfc.bus.uart TX: 55 55 00 00 00 00 00 00 00 00 00 00 00 00 00 00
debug libnfc.chip.pn53x SAMConfiguration
debug libnfc.chip.pn53x Timeout value: 1000
debug libnfc.bus.uart TX: 00 00 ff 03 fd d4 14 01 17 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 02 fe
debug libnfc.bus.uart RX: d5 15
debug libnfc.bus.uart RX: 16 00
debug libnfc.bus.uart TX: 00 00 ff 09 f7 d4 00 00 6c 69 62 6e 66 63 be 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 09 f7
debug libnfc.bus.uart RX: d5 01
debug libnfc.bus.uart RX: 00 6c 69 62 6e 66 63
debug libnfc.bus.uart RX: bc 00
debug libnfc.chip.pn53x GetFirmwareVersion
debug libnfc.bus.uart TX: 00 00 ff 02 fe d4 02 2a 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 06 fa
debug libnfc.bus.uart RX: d5 03
debug libnfc.bus.uart RX: 32 01 06 07
debug libnfc.bus.uart RX: e8 00
debug libnfc.chip.pn53x SetParameters
debug libnfc.bus.uart TX: 00 00 ff 03 fd d4 12 14 06 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 02 fe
debug libnfc.bus.uart RX: d5 13
debug libnfc.bus.uart RX: 18 00
debug libnfc.general "pn532_uart:/dev/tty.SLAB_USBtoUART" (pn532_uart:/dev/tty.SLAB_USBtoUART) has been claimed.
debug libnfc.chip.pn53x ReadRegister
debug libnfc.bus.uart TX: 00 00 ff 0c f4 d4 06 63 02 63 03 63 0d 63 38 63 3d b0 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 07 f9
debug libnfc.bus.uart RX: d5 07
debug libnfc.bus.uart RX: 00 00 00 00 00
debug libnfc.bus.uart RX: 24 00
debug libnfc.chip.pn53x PN53X_REG_CIU_TxMode (Defines the transmission data rate and framing during transmission)
debug libnfc.chip.pn53x PN53X_REG_CIU_RxMode (Defines the transmission data rate and framing during receiving)
debug libnfc.chip.pn53x WriteRegister
debug libnfc.bus.uart TX: 00 00 ff 08 f8 d4 08 63 02 80 63 03 80 59 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 02 fe
debug libnfc.bus.uart RX: d5 09
debug libnfc.bus.uart RX: 22 00
debug libnfc.chip.pn53x RFConfiguration
debug libnfc.bus.uart TX: 00 00 ff 04 fc d4 32 01 00 f9 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 02 fe
debug libnfc.bus.uart RX: d5 33
debug libnfc.bus.uart RX: f8 00
debug libnfc.chip.pn53x RFConfiguration
debug libnfc.bus.uart TX: 00 00 ff 04 fc d4 32 01 01 f8 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 02 fe
debug libnfc.bus.uart RX: d5 33
debug libnfc.bus.uart RX: f8 00
debug libnfc.chip.pn53x RFConfiguration
debug libnfc.bus.uart TX: 00 00 ff 06 fa d4 32 05 ff ff ff f8 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 02 fe
debug libnfc.bus.uart RX: d5 33
debug libnfc.bus.uart RX: f8 00
debug libnfc.chip.pn53x ReadRegister
debug libnfc.bus.uart TX: 00 00 ff 0e f2 d4 06 63 02 63 03 63 05 63 38 63 3c 63 3d 19 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 08 f8
debug libnfc.bus.uart RX: d5 07
debug libnfc.bus.uart RX: 80 80 00 00 00 00
debug libnfc.bus.uart RX: 24 00
debug libnfc.chip.pn53x PN53X_REG_CIU_TxAuto (Controls the settings of the antenna driver)
debug libnfc.chip.pn53x PN53X_REG_CIU_Control (Contains miscellaneous control bits)
debug libnfc.chip.pn53x WriteRegister
debug libnfc.bus.uart TX: 00 00 ff 08 f8 d4 08 63 05 40 63 3c 10 cd 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 02 fe
debug libnfc.bus.uart RX: d5 09
debug libnfc.bus.uart RX: 22 00
debug libnfc.chip.pn53x RFConfiguration
debug libnfc.bus.uart TX: 00 00 ff 04 fc d4 32 01 00 f9 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 02 fe
debug libnfc.bus.uart RX: d5 33
debug libnfc.bus.uart RX: f8 00
debug libnfc.chip.pn53x RFConfiguration
debug libnfc.bus.uart TX: 00 00 ff 06 fa d4 32 05 00 01 02 f2 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 02 fe
debug libnfc.bus.uart RX: d5 33
debug libnfc.bus.uart RX: f8 00
debug libnfc.chip.pn53x ReadRegister
debug libnfc.bus.uart TX: 00 00 ff 04 fc d4 06 63 03 c0 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 03 fd
debug libnfc.bus.uart RX: d5 07
debug libnfc.bus.uart RX: 80
debug libnfc.bus.uart RX: a4 00
debug libnfc.chip.pn53x PN53X_REG_CIU_RxMode (Defines the transmission data rate and framing during receiving)
debug libnfc.chip.pn53x WriteRegister
debug libnfc.bus.uart TX: 00 00 ff 05 fb d4 08 63 03 88 36 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 02 fe
debug libnfc.bus.uart RX: d5 09
debug libnfc.bus.uart RX: 22 00
debug libnfc.chip.pn53x RFConfiguration
debug libnfc.bus.uart TX: 00 00 ff 04 fc d4 32 01 01 f8 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 02 fe
debug libnfc.bus.uart RX: d5 33
debug libnfc.bus.uart RX: f8 00
debug libnfc.chip.pn53x RFConfiguration
debug libnfc.bus.uart TX: 00 00 ff 04 fc d4 32 01 00 f9 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 02 fe
debug libnfc.bus.uart RX: d5 33
debug libnfc.bus.uart RX: f8 00
debug libnfc.chip.pn53x RFConfiguration
debug libnfc.bus.uart TX: 00 00 ff 04 fc d4 32 01 01 f8 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 02 fe
debug libnfc.bus.uart RX: d5 33
debug libnfc.bus.uart RX: f8 00
debug libnfc.chip.pn53x RFConfiguration
debug libnfc.bus.uart TX: 00 00 ff 04 fc d4 32 01 00 f9 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 02 fe
debug libnfc.bus.uart RX: d5 33
debug libnfc.bus.uart RX: f8 00
debug libnfc.chip.pn53x RFConfiguration
debug libnfc.bus.uart TX: 00 00 ff 04 fc d4 32 01 01 f8 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 02 fe
debug libnfc.bus.uart RX: d5 33
debug libnfc.bus.uart RX: f8 00
debug libnfc.chip.pn53x RFConfiguration
debug libnfc.bus.uart TX: 00 00 ff 06 fa d4 32 05 00 01 02 f2 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 02 fe
debug libnfc.bus.uart RX: d5 33
debug libnfc.bus.uart RX: f8 00
debug libnfc.chip.pn53x InListPassiveTarget
debug libnfc.chip.pn53x No timeout
debug libnfc.bus.uart TX: 00 00 ff 04 fc d4 4a 01 00 e1 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 20 e0
debug libnfc.bus.uart RX: d5 4b
debug libnfc.bus.uart RX: 01 01 00 44 28 07 04 1b 15 4a 0e 35 80 11 78 f7 b1 02 59 75 62 69 6b 65 79 4e 45 4f 72 33
debug libnfc.bus.uart RX: 8e 00
debug libnfc.chip.pn53x RFConfiguration
debug libnfc.bus.uart TX: 00 00 ff 04 fc d4 32 01 00 f9 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 02 fe
debug libnfc.bus.uart RX: d5 33
debug libnfc.bus.uart RX: f8 00
debug libnfc.chip.pn53x RFConfiguration
debug libnfc.bus.uart TX: 00 00 ff 04 fc d4 32 01 01 f8 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 02 fe
debug libnfc.bus.uart RX: d5 33
debug libnfc.bus.uart RX: f8 00
debug libnfc.chip.pn53x RFConfiguration
debug libnfc.bus.uart TX: 00 00 ff 06 fa d4 32 05 00 01 02 f2 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 02 fe
debug libnfc.bus.uart RX: d5 33
debug libnfc.bus.uart RX: f8 00
debug libnfc.chip.pn53x InListPassiveTarget
debug libnfc.chip.pn53x No timeout
debug libnfc.bus.uart TX: 00 00 ff 04 fc d4 4a 01 00 e1 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 20 e0
debug libnfc.bus.uart RX: d5 4b
debug libnfc.bus.uart RX: 01 01 00 44 28 07 04 1b 15 4a 0e 35 80 11 78 f7 b1 02 59 75 62 69 6b 65 79 4e 45 4f 72 33
debug libnfc.bus.uart RX: 8e 00
debug libnfc.chip.pn53x SetParameters
debug libnfc.bus.uart TX: 00 00 ff 03 fd d4 12 04 16 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 02 fe
debug libnfc.bus.uart RX: d5 13
debug libnfc.bus.uart RX: 18 00
debug libnfc.chip.pn53x RFConfiguration
debug libnfc.bus.uart TX: 00 00 ff 04 fc d4 32 01 00 f9 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 02 fe
debug libnfc.bus.uart RX: d5 33
debug libnfc.bus.uart RX: f8 00
debug libnfc.chip.pn53x RFConfiguration
debug libnfc.bus.uart TX: 00 00 ff 04 fc d4 32 01 01 f8 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 02 fe
debug libnfc.bus.uart RX: d5 33
debug libnfc.bus.uart RX: f8 00
debug libnfc.chip.pn53x RFConfiguration
debug libnfc.bus.uart TX: 00 00 ff 06 fa d4 32 05 00 01 02 f2 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 02 fe
debug libnfc.bus.uart RX: d5 33
debug libnfc.bus.uart RX: f8 00
debug libnfc.chip.pn53x InListPassiveTarget
debug libnfc.chip.pn53x No timeout
debug libnfc.bus.uart TX: 00 00 ff 04 fc d4 4a 01 00 e1 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 0f f1
debug libnfc.bus.uart RX: d5 4b
debug libnfc.bus.uart RX: 01 01 00 44 28 07 04 1b 15 4a 0e 35 80
debug libnfc.bus.uart RX: 2a 00
debug libnfc.chip.pn53x InDataExchange
debug libnfc.bus.uart TX: 00 00 ff 12 ee d4 40 01 60 00 a0 a1 a2 a3 a4 a5 04 1b 15 4a 0e 35 80 7b 00
debug libnfc.bus.uart RX: 00 00 ff 00 ff 00
debug libnfc.chip.pn53x PN53x ACKed
debug libnfc.bus.uart RX: 00 00 ff 01 ff
debug libnfc.bus.uart RX: 7f 81 00
error libnfc.driver.pn532_uart Application level error detected
```
Карта имеет 7-байтный UID
```
ATQA (SENS_RES): 00 44
UID (NFCID1): 04 1b b1 4e f7 00 f1
SAK (SEL_RES): 28
ATS: 78 f7 b1 02 59 75 62 69 6b 65 79 4e 45 4f 72 33
```
Физически RFID-метка работает довольно хорошо, несмотря на маленькую антенну, ридер в метро «схватывает» с 3 сантиметров.
#### Заключение
По сравнению со всеми аппаратными токенами, которыми мне доводилось пользоваться, технология U2F — это крайне удобно. Не нужно возиться с импортом сертификатов, установкой драйверов, никаких Java-апплетов и прочего.
Я протестировал работу на Windows 7, Mac OS 10.10 и Ubuntu 14.0.4. Во всех системах Chrome сразу подхватывал токен без установки драйверов. В целом, развертывание видится настолько простым и понятным, что справится даже ребенок.
А наличие полностью открытых спецификаций, плагинов и библиотек позволит прикручивать U2F к любым приложениям. | https://habr.com/ru/post/256579/ | null | ru | null |
# Как Discord хранит миллиарды сообщений
Discord продолжает расти быстрее, чем мы ожидали, как и пользовательский контент. Чем больше пользователей — тем больше сообщений в чате. В июле мы [объявили о 40 млн сообщений в день](https://blog.discordapp.com/11-million-players-in-one-year/), в декабре [объявили о 100 млн](http://venturebeat.com/2016/12/08/discord-hits-25-million-users-and-releases-gamebridge-sdk-for-its-voice-chat/), а в середине января преодолели 120 млн. Мы сразу решили хранить историю чатов вечно, так что пользователи могут вернуться в любой момент и получить доступ к своим данным с любого устройства. Это много данных, поток и объём которых нарастает, и все они должны быть доступными. *Как мы это делаем? Cassandra!*
Что мы делали
=============
Изначальную версию Discord написали быстрее чем за два месяца в начале 2015 года. Возможно, одной из лучших СУБД для быстрого выполнения итераций является MongoDB. Всё в Discord специально хранилось в едином реплисете (replica set) MongoDB, но мы также готовили всё для простой миграции в новую СУБД (мы знали, что не собираемся использовать шардинг MongoDB из-за его сложности и неизвестной стабильности). На самом деле это часть нашей корпоративной культуры: разрабатывай быстро, чтобы испытать новую функцию продукта, но всегда с курсом на более надёжное решение.
Сообщения хранились в коллекции MongoDB с единым составным индексом на `channel_id` и `created_at`. Примерно в ноябре 2015 года мы вышли на рубеж 100 млн сообщений в базе, и тогда начали понимать проблемы, которые нас ждут: данные и индекс больше не помещаются в ОЗУ, а задержки становятся непредсказуемыми. Пришло время мигрировать в более подходящую СУБД.
Выбор правильной СУБД
=====================
Перед выбором новой СУБД нам требовалось понять имеющиеся шаблоны чтения/записи и почему возникли проблемы с текущим решением.
* Быстро стало понятно, что операции чтения исключительно случайны, а соотношения чтение/запись примерно 50/50.
* Тяжёлые серверы голосовых чатов Discord практически не присылали сообщений. То есть они присылали одно или два сообщения каждые несколько дней. За год сервер такого типа вряд ли достигнет рубежа в 1000 сообщений. Проблема в том, что даже несмотря на такое малое количество сообщений, эти данные труднее доставлять пользователям. Просто возвращение пользователю 50-ти сообщений может привести к многим случайным операциям поиска на диске, что приводит к вытеснению дискового кэша.
* Тяжёлые серверы приватных текстовых чатов Discord отправляют приличное количество сообщений, легко попадая в диапазон между 100 тыс. и 1 млн сообщений в год. Запрашивают они обычно только самые последние данные. Проблема в том, что на этих серверах обычно менее 100 участников, так что скорость запроса данных низкая и вряд ли они будут в дисковом кэше.
* Большие публичные серверы Discord отправляют очень много сообщений. Там тысячи участников, отправляющих тысячи сообщений в день. Легко набираются миллионы сообщений в год. Они почти всегда запрашивают сообщения, отправленные в последний час, и это происходит часто. Поэтому данные обычно находятся в дисковом кэше.
* Мы знали, что в наступающем году у пользователей появится ещё больше способов генерировать случайные чтения: это возможность просматривать свои упоминания за последние 30 дней и затем перескакивать в тот момент истории, просмотр и переход к прикреплённым сообщениям и полнотекстовый поиск. *Всё это означает ещё больше случайных чтений!*
Затем мы определили наши требования:
* **Линейная масштабируемость** — Мы не хотим пересматривать решение позже или вручную переносить данные в другой шард.
* **Автоматическая отказоустойчивость** — Нам нравится спать по ночам и делать Discord настолько самоисцеляющимся, насколько это возможно.
* **Небольшая поддержка** — Она должна работать сразу же, как мы её установим. От нас требуется только добавлять больше нод по мере увеличения данных.
* **Доказано в работе** — Мы любим пробовать новые технологии, но не слишком новые.
* **Предсказуемая производительность** — Нам отправляются сообщения, если время отклика API в 95% случаев превышает 80 мс. Мы также не хотим сталкиваться с необходимостью кэшировать сообщения в Redis или Memcached.
* **Не хранилище блобов** — Запись тысяч сообщений в секунду не будет отлично работать, если нам придётся непрерывно десериализировать блобы и присоединять к ним данные.
* **Open source** — Мы верим, что управляем собственной судьбой, и не хотим зависеть от сторонней компании.
Cassandra оказалась единственной СУБД, которая удовлетворила всем нашим требованиям. Мы можем просто добавлять ноды при масштабировании, а она справляется с потерей нод без всякого влияния на приложение. В больших компаниях вроде Netflix и Apple — тысячи нод Cassandra. Связанные данные хранятся рядом на диске, обеспечивая минимум операций поиска и лёгкое распределение по кластеру. Она поддерживается компанией DataStax, но распространяется с открытым исходным кодом и силами сообщества.
Сделав выбор, нужно было доказать, что он действительно оправдан.
Моделирование данных
====================
Лучший способ описать новичку Cassandra — это аббревиатура KKV. Две буквы “K” содержат в себе первичный ключ. Первая “K” — это ключ раздела. Он помогает определить, в какой ноде живут данные и где их найти на диске. Внутри раздела множество строк, и конкретную строку внутри раздела определяет вторая “K” — ключ кластеризации. Он работает как первичный ключ внутри раздела и определяет способ сортировки строк. Можете представить раздел как упорядоченный словарь. Все эти качества вместе взятые позволяют очень мощное моделирование данных.
Помните, что сообщения в MongoDB индексировались с использованием `channel_id` и `created_at`? `channel_id` стал ключом раздела, поскольку все сообщения работают в канале, но `created_at` не даёт хорошего ключа кластеризации, потому что два сообщения могут быть созданы в одно время. К счастью, каждый ID в Discord на самом деле создан в [Snowflake](https://blog.twitter.com/2010/announcing-snowflake), то есть хронологически сортируется. Так что можно было использовать именно их. Первичный ключ превратился в `(channel_id, message_id)`, где `message_id` — это Snowflake. Это значит, что при загрузке канала мы можем сказать Cassandra точный диапазон, где искать сообщения.
Вот упрощённая схема для нашей таблицы сообщений (она пропускает примерно 10 колонок).
```
CREATE TABLE messages (
channel_id bigint,
message_id bigint,
author_id bigint,
content text,
PRIMARY KEY (channel_id, message_id)
) WITH CLUSTERING ORDER BY (message_id DESC);
```
Хотя схемы у Cassandra и похожи на схемы реляционных БД, их легко изменять, что не оказывает какого-либо временного влияния на производительность. Мы взяли лучшее от хранилища блобов и реляционного хранилища.
Как только начался импорт существующих сообщений в Cassandra, мы сразу увидели в логах предупреждения, что найдены разделы размером более 100 МБ. *Да ну?! Ведь Cassandra заявляет о поддержке разделов 2 ГБ!* По всей видимости, сама возможность не означает, что так нужно делать. Большие разделы накладывают сильную нагрузку на сборщик мусора в Cassandra при уплотнении, расширении кластера и т.д. Наличие большого раздела также означает, что данные в нём нельзя распределить по кластеру. Стало ясно, что нам придётся как-то ограничить размеры разделов, потому что некоторые каналы Discord могут существовать годами и постоянно увеличиваться в размере.
Мы решили распределить наши сообщения блоками (buckets) по времени. Мы посмотрели на самые большие каналы в Discord и определили, что если хранить сообщения блоками примерно по 10 дней, то комфортно вложимся в лимит 100 МБ. Блоки нужно получать из `message_id` или метки времени.
```
DISCORD_EPOCH = 1420070400000
BUCKET_SIZE = 1000 * 60 * 60 * 24 * 10
def make_bucket(snowflake):
if snowflake is None:
timestamp = int(time.time() * 1000) - DISCORD_EPOCH
else:
# When a Snowflake is created it contains the number of
# seconds since the DISCORD_EPOCH.
timestamp = snowflake_id >> 22
return int(timestamp / BUCKET_SIZE)
def make_buckets(start_id, end_id=None):
return range(make_bucket(start_id), make_bucket(end_id) + 1)
```
Ключи разделов Cassandra могут быть составными, так что нашим новым первичным ключом стал `((channel_id, bucket), message_id)`.
```
CREATE TABLE messages (
channel_id bigint,
bucket int,
message_id bigint,
author_id bigint,
content text,
PRIMARY KEY ((channel_id, bucket), message_id)
) WITH CLUSTERING ORDER BY (message_id DESC);
```
Для запроса недавних сообщений в канале мы сгенерировали диапазон блоков от текущего времени до `channel_id` (он тоже хронологически сортируется как Snowflake и должен быть старше, чем первое сообщение). Затем мы последовательно опрашиваем разделы до тех пор, пока не соберём достаточно сообщений. Обратная сторона такого метода в том, что изредка активным инстансам Discord придётся опрашивать много разных блоков, чтобы собрать достаточно сообщений со временем. На практике оказалось, что всё в порядке, потому что для активного инстанса Discord обычно находится достаточно сообщений в первом разделе, и таких большинство.
Импорт сообщений в Cassandra прошёл без помех, и мы были готовы опробовать её в производстве.
Тяжёлый запуск
==============
Выводить новую систему в производство всегда страшно, так что хорошей идеей будет проверить её, не затрагивая пользователей. Мы настроили систему на дублирование операций чтения/записи в MongoDB и Cassandra.
Немедленно после запуска в баг-трекере появились ошибки, что `author_id` равен нулю. *Как он может быть нулевым? Это обязательное поле!*
Согласованность в конечном счёте
================================
Cassandra — система типа [AP](https://ru.wikipedia.org/wiki/Теорема_CAP), то есть гарантированная целостность здесь приносится в жертву доступности, что мы и хотели, в общем. В Cassandra противопоказано чтение перед записью (операции чтения более дорогие) и поэтому всё, что делает Cassandra, — это обновление и вставку (upsert), даже если предоставить только определённые колонки. Вы также можете писать в любую ноду, и она автоматически разрешит конфликты, используя семантику «последняя запись выигрывает» по каждой колонке. *Так как это нас коснулось?*
*Пример состояния гонки редактирование/удаление*
В случае, если пользователь редактировал сообщение, в то время как другой пользователь удалял то же самое сообщение, у нас появлялась строка с полностью отсутствующими данными, за исключением первичного ключа и текста, потому что Cassandra записывает только обновления и вставки. Для этой проблемы есть два возможных решения:
1. Записывать обратно целое сообщение во время редактирования сообщения. Тогда есть возможность воскрешения удалённых сообщений и добавляются шансы конфликтов для одновременных записей в другие колонки.
2. Выявить повреждённое сообщение и удалить его из базы.
Мы выбрали второй вариант, определив требуемую колонку (в этом случае `author_id`) и удаляя сообщение, если оно пустое.
Решая эту проблему, мы заметили, что были весьма неэффективны с операциями записи. Поскольку Cassandra согласована в конечном счёте, то она не может вот так взять и немедленно удалить данные. Ей нужно реплицировать удаления на другие ноды, и это следует сделать даже если ноды временно недоступны. Cassandra справляется с этим, приравнивая удаление к своеобразной форме записи под названием “tombstone” («надгробие»). Во время операции чтения она просто проскакивает через «надгробия», которые встречаются по пути. Время жизни «надгробий» настраивается (по умолчанию, 10 дней), и они навсегда удаляются во время уплотнения базы, если срок вышел.
Удаление колонки и запись нуля в колонку — это абсолютно одно и то же. В обоих случаях создаётся «надгробие». Поскольку все записи в Cassandra являются обновлениями и вставками, то вы создаёте «надгробие» даже если изначально записываете нуль. На практике, наша полная схема сообщения состояла из 16 колонок, но среднее сообщение имело только 4 установленных значения. Мы записывали 12 «надгробий» в Cassandra, обычно без всякой причины. Решение проблемы было простым: записывать в базу только ненулевые значения.
Производительность
==================
Известно, что Cassandra быстрее выполняет операции записи, чем чтения, и мы наблюдали в точности это. Операции записи происходили в интервале менее миллисекунды, а операции чтения — менее 5 миллисекунд. Такие показатели наблюдались независимо от типа данных, к которым осуществлялся доступ. Производительность сохранялась неизменной в течение недели тестирования. *Ничего удивительного, мы получили в точности то, чего ожидали.*
*Задержка чтения/записи, по данным из лога*
В соответствии с быстрой, надёжной производительностью чтения, вот пример перехода к сообщению годичной давности в канале с миллионами сообщений:
Большой сюрприз
===============
Всё прошло гладко, так что мы выкатили Cassandra как нашу основную базу данных и вывели из строя MongoDB в течение недели. Она продолжала безукоризненно работать… примерно 6 месяцев, пока однажды не перестала реагировать.
Мы заметили, что Cassandra непрерывно останавливается на 10 секунд во время сборки мусора, но совершенно не могли понять, почему. Начали копать — и нашли канал Discord, который требовал 20 секунд для загрузки. Виновником был публичный Discord-сервер [подреддита Puzzles & Dragons](https://www.reddit.com/r/PuzzleAndDragons/). Поскольку он публичный, мы присоединились посмотреть. К нашему удивлению, на канале было только одно сообщение. В тот момент стало очевидно, что они удалили миллионы сообщений через наши API, оставив только одно сообщение на канале.
Если вы внимательно читали, то помните, как Cassandra обрабатывает удаления при помощи «надгробий» (упомянуто в главе «Согласованность в конечном счёте»). Когда пользователь загружает этот канал, хоть там одно сообщение, Cassandra приходится эффективно сканировать миллионы «надгробий» сообщений. Тогда она генерирует мусор быстрее, чем JVM может собрать его.
Мы решили эту проблему следующим образом:
* Уменьшили время жизни надгробий с 10 дней до 2 дней, потому что мы каждый вечер запускаем [починку Cassandra](https://docs.datastax.com/en/cassandra/2.1/cassandra/tools/toolsRepair.html#toolsRepair__description) (противоэнтропийный процесс) на нашем кластере сообщений.
* Изменили код запросов, чтобы отслеживать пустые блоки на канале и избегать их в будущем. Это значит, что если пользователь снова инициировал этот запрос, то в худшем случае Cassandra будет сканировать только самый последний блок.
Будущее
=======
В данный момент у нас работает кластер из 12 нодов с коэффициентом репликации 3, и мы продолжим добавлять новые ноды Cassandra по мере надобности. Мы верим, что этот подход работоспособен в долговременной перспективе, но по мере роста Discord просматривается отдалённое будущее, когда придётся сохранять миллиарды сообщений в день. У Netflix и Apple работают кластеры с сотнями нодов, поэтому пока что нам не о чем волноваться. Однако хочется иметь пару идей про запас.
### Ближайшее будущее
* Обновить наш кластер сообщений с Cassandra 2 на Cassandra 3. [Новый формат хранения](http://www.datastax.com/2015/12/storage-engine-30) в Cassandra 3 может сократить объём хранения более чем на 50%.
* Более новые версии Cassandra лучше справляются с обработкой большего количества данных в каждом ноде. Мы сейчас храним примерно 1 ТБ сжатых данных в каждом из них. Думаем, что можно безопасно сократить количество нодов в кластере, увеличив этот лимит до 2 ТБ.
### Отдалённое будущее
* Изучить [Scylla](http://www.scylladb.com/) — это СУБД, совместимая с Cassandra и написанная на C++. В нормальной работе наши ноды Cassandra в реальности потребляют немного ресурсов CPU, однако в непиковые часы во время починки Cassandra (противоэнтропийный процесс) они довольно сильно зависят от CPU, а время починки возрастает в зависимости от количества данных, записанных с момента прошлой починки. Scylla обещает значительно увеличить скорость починки.
* Создать систему для архивации неиспользуемых каналов в Google Cloud Storage и загрузки их обратно по требованию. Мы хотим избежать этого и не думаем, что такое придётся делать.
### Заключение
Прошло уже больше года с момента перехода на Cassandra, и несмотря на *«большой сюрприз»*, это было спокойное плавание. Мы вышли с более 100 миллионов общего количества сообщений на более чем 120 миллионов сообщений в день, сохранив производительность и стабильность.
Благодаря успеху этого проекта, с тех пор мы перенесли все остальные наши данные в производстве на Cassandra, и тоже успешно.
В продолжении этой статьи мы исследуем, как мы осуществляем полнотекстовый поиск по миллиардам сообщений.
У нас до сих пор нет специализированных инженеров DevOps (только четыре инженера бэкенда), так что очень классно иметь систему, о которой не приходится волноваться. *Мы набираем сотрудников, так что [обращайтесь](https://discordapp.com/company#section-company-join), если подобные задачки щекочут ваше воображение.* | https://habr.com/ru/post/323694/ | null | ru | null |
# Разработка надёжных Python-скриптов
Python — это язык программирования, который отлично подходит для разработки самостоятельных скриптов. Для того чтобы добиться с помощью подобного скрипта желаемого результата, нужно написать несколько десятков или сотен строк кода. А после того, как дело сделано, можно просто забыть о написанном коде и перейти к решению следующей задачи.
Если, скажем, через полгода после того, как был написан некий «одноразовый» скрипт, кто-то спросит его автора о том, почему этот скрипт даёт сбои, об этом может не знать и автор скрипта. Происходит подобное из-за того, что к такому скрипту не была написана документация, из-за использования параметров, жёстко заданных в коде, из-за того, что скрипт ничего не логирует в ходе работы, и из-за отсутствия тестов, которые позволили бы быстро понять причину проблемы.
[](https://habr.com/ru/company/ruvds/blog/462007/)
При этом надо отметить, что превратить скрипт, написанный на скорую руку, в нечто гораздо более качественное, не так уж и сложно. А именно, такой скрипт довольно легко превратить в надёжный и понятный код, которым удобно пользоваться, в код, который просто поддерживать как его автору, так и другим программистам.
Автор материала, перевод которого мы сегодня публикуем, собирается продемонстрировать подобное «превращение» на примере классической задачи «[Fizz Buzz Test](http://wiki.c2.com/?FizzBuzzTest)». Эта задача заключается в том, чтобы вывести список чисел от 1 до 100, заменив некоторые из них особыми строками. Так, если число кратно 3 — вместо него нужно вывести строку `Fizz`, если число кратно 5 — строку `Buzz`, а если соблюдаются оба этих условия — `FizzBuzz`.
Исходный код
------------
Вот исходный код Python-скрипта, который позволяет решить задачу:
```
import sys
for n in range(int(sys.argv[1]), int(sys.argv[2])):
if n % 3 == 0 and n % 5 == 0:
print("fizzbuzz")
elif n % 3 == 0:
print("fizz")
elif n % 5 == 0:
print("buzz")
else:
print(n)
```
Поговорим о том, как его улучшить.
Документация
------------
Я считаю, что полезно писать документацию до написания кода. Это упрощает работу и помогает не затягивать создание документации до бесконечности. Документацию к скрипту можно поместить в его верхнюю часть. Например, она может выглядеть так:
```
#!/usr/bin/env python3
"""Simple fizzbuzz generator.
This script prints out a sequence of numbers from a provided range
with the following restrictions:
- if the number is divisible by 3, then print out "fizz",
- if the number is divisible by 5, then print out "buzz",
- if the number is divisible by 3 and 5, then print out "fizzbuzz".
"""
```
В первой строке даётся краткое описание цели скрипта. В оставшихся абзацах содержатся дополнительные сведения о том, что именно делает скрипт.
Аргументы командной строки
--------------------------
Следующей задачей по улучшению скрипта станет замена значений, жёстко заданных в коде, на документированные значения, передаваемые скрипту через аргументы командной строки. Реализовать это можно с использованием модуля [argparse](https://docs.python.org/3/library/argparse.html). В нашем примере мы предлагаем пользователю указать диапазон чисел и указать значения для «fizz» и «buzz», используемые при проверке чисел из указанного диапазона.
```
import argparse
import sys
class CustomFormatter(argparse.RawDescriptionHelpFormatter,
argparse.ArgumentDefaultsHelpFormatter):
pass
def parse_args(args=sys.argv[1:]):
"""Parse arguments."""
parser = argparse.ArgumentParser(
description=sys.modules[__name__].__doc__,
formatter_class=CustomFormatter)
g = parser.add_argument_group("fizzbuzz settings")
g.add_argument("--fizz", metavar="N",
default=3,
type=int,
help="Modulo value for fizz")
g.add_argument("--buzz", metavar="N",
default=5,
type=int,
help="Modulo value for buzz")
parser.add_argument("start", type=int, help="Start value")
parser.add_argument("end", type=int, help="End value")
return parser.parse_args(args)
options = parse_args()
for n in range(options.start, options.end + 1):
# ...
```
Эти изменения приносят скрипту огромную пользу. А именно, параметры теперь надлежащим образом документированы, выяснить их предназначение можно с помощью флага `--help`. Более того, по соответствующей команде выводится и документация, которую мы написали в предыдущем разделе:
```
$ ./fizzbuzz.py --help
usage: fizzbuzz.py [-h] [--fizz N] [--buzz N] start end
Simple fizzbuzz generator.
This script prints out a sequence of numbers from a provided range
with the following restrictions:
- if the number is divisible by 3, then print out "fizz",
- if the number is divisible by 5, then print out "buzz",
- if the number is divisible by 3 and 5, then print out "fizzbuzz".
positional arguments:
start Start value
end End value
optional arguments:
-h, --help show this help message and exit
fizzbuzz settings:
--fizz N Modulo value for fizz (default: 3)
--buzz N Modulo value for buzz (default: 5)
```
Модуль `argparse` — это весьма мощный инструмент. Если вы с ним не знакомы — вам полезно будет просмотреть [документацию](https://docs.python.org/3/library/argparse.html) по нему. Мне, в частности, нравятся его возможности по определению [подкоманд](https://docs.python.org/3/library/argparse.html#sub-commands) и [групп аргументов](https://docs.python.org/3/library/argparse.html#argument-groups).
Логирование
-----------
Если оснастить скрипт возможностями по выводу некоей информации в ходе его выполнения — это окажется приятным дополнением к его функционалу. Для этой цели хорошо подходит модуль [logging](https://docs.python.org/3/library/logging.html). Для начала опишем объект, реализующий логирование:
```
import logging
import logging.handlers
import os
import sys
logger = logging.getLogger(os.path.splitext(os.path.basename(sys.argv[0]))[0])
```
Затем сделаем так, чтобы подробностью сведений, выводимых при логировании, можно было бы управлять. Так, команда `logger.debug()` должна выводить что-то только в том случае, если скрипт запускают с ключом `--debug`. Если же скрипт запускают с ключом `--silent` — скрипт не должен выводить ничего кроме сообщений об исключениях. Для реализации этих возможностей добавим в `parse_args()` следующий код:
```
# В parse_args()
g = parser.add_mutually_exclusive_group()
g.add_argument("--debug", "-d", action="store_true",
default=False,
help="enable debugging")
g.add_argument("--silent", "-s", action="store_true",
default=False,
help="don't log to console")
```
Добавим в код проекта следующую функцию для настройки логирования:
```
def setup_logging(options):
"""Configure logging."""
root = logging.getLogger("")
root.setLevel(logging.WARNING)
logger.setLevel(options.debug and logging.DEBUG or logging.INFO)
if not options.silent:
ch = logging.StreamHandler()
ch.setFormatter(logging.Formatter(
"%(levelname)s[%(name)s] %(message)s"))
root.addHandler(ch)
```
Основной код скрипта при этом изменится так:
```
if __name__ == "__main__":
options = parse_args()
setup_logging(options)
try:
logger.debug("compute fizzbuzz from {} to {}".format(options.start,
options.end))
for n in range(options.start, options.end + 1):
# ..
except Exception as e:
logger.exception("%s", e)
sys.exit(1)
sys.exit(0)
```
Если скрипт планируется запускать без прямого участия пользователя, например, с помощью `crontab`, можно сделать так, чтобы его вывод поступал бы в `syslog`:
```
def setup_logging(options):
"""Configure logging."""
root = logging.getLogger("")
root.setLevel(logging.WARNING)
logger.setLevel(options.debug and logging.DEBUG or logging.INFO)
if not options.silent:
if not sys.stderr.isatty():
facility = logging.handlers.SysLogHandler.LOG_DAEMON
sh = logging.handlers.SysLogHandler(address='/dev/log',
facility=facility)
sh.setFormatter(logging.Formatter(
"{0}[{1}]: %(message)s".format(
logger.name,
os.getpid())))
root.addHandler(sh)
else:
ch = logging.StreamHandler()
ch.setFormatter(logging.Formatter(
"%(levelname)s[%(name)s] %(message)s"))
root.addHandler(ch)
```
В нашем небольшом скрипте неоправданно большим кажется подобный объём кода, нужный только для того, чтобы воспользоваться командой `logger.debug()`. Но в реальных скриптах этот код уже таким не покажется и на первый план выйдет польза от него, заключающаяся в том, что с его помощью пользователи смогут узнавать о ходе решения задачи.
```
$ ./fizzbuzz.py --debug 1 3
DEBUG[fizzbuzz] compute fizzbuzz from 1 to 3
1
2
fizz
```
Тесты
-----
Модульные тесты — это полезнейшее средство для проверки того, ведёт ли себя приложения так, как нужно. В скриптах модульные тесты используют нечасто, но их включение в скрипты значительно улучшает надёжность кода. Преобразуем код, находящийся внутри цикла, в функцию, и опишем несколько интерактивных примеров её использования в её документации:
```
def fizzbuzz(n, fizz, buzz):
"""Compute fizzbuzz nth item given modulo values for fizz and buzz.
>>> fizzbuzz(5, fizz=3, buzz=5)
'buzz'
>>> fizzbuzz(3, fizz=3, buzz=5)
'fizz'
>>> fizzbuzz(15, fizz=3, buzz=5)
'fizzbuzz'
>>> fizzbuzz(4, fizz=3, buzz=5)
4
>>> fizzbuzz(4, fizz=4, buzz=6)
'fizz'
"""
if n % fizz == 0 and n % buzz == 0:
return "fizzbuzz"
if n % fizz == 0:
return "fizz"
if n % buzz == 0:
return "buzz"
return n
```
Проверить правильность работы функции можно с помощью `pytest`:
```
$ python3 -m pytest -v --doctest-modules ./fizzbuzz.py
============================ test session starts =============================
platform linux -- Python 3.7.4, pytest-3.10.1, py-1.8.0, pluggy-0.8.0 -- /usr/bin/python3
cachedir: .pytest_cache
rootdir: /home/bernat/code/perso/python-script, inifile:
plugins: xdist-1.26.1, timeout-1.3.3, forked-1.0.2, cov-2.6.0
collected 1 item
fizzbuzz.py::fizzbuzz.fizzbuzz PASSED [100%]
========================== 1 passed in 0.05 seconds ==========================
```
Для того чтобы всё это заработало, нужно, чтобы после имени скрипта шло бы расширение `.py`. Мне не нравится добавлять расширения к именам скриптов: язык — это лишь техническая деталь, которую не нужно демонстрировать пользователю. Однако возникает такое ощущение, что оснащение имени скрипта расширением — это самый простой способ позволить системам для запуска тестов, вроде `pytest`, находить тесты, включённые в код.
В случае возникновения ошибки `pytest` выведет сообщение, указывающее на расположение соответствующего кода и на суть проблемы:
```
$ python3 -m pytest -v --doctest-modules ./fizzbuzz.py -k fizzbuzz.fizzbuzz
============================ test session starts =============================
platform linux -- Python 3.7.4, pytest-3.10.1, py-1.8.0, pluggy-0.8.0 -- /usr/bin/python3
cachedir: .pytest_cache
rootdir: /home/bernat/code/perso/python-script, inifile:
plugins: xdist-1.26.1, timeout-1.3.3, forked-1.0.2, cov-2.6.0
collected 1 item
fizzbuzz.py::fizzbuzz.fizzbuzz FAILED [100%]
================================== FAILURES ==================================
________________________ [doctest] fizzbuzz.fizzbuzz _________________________
100
101 >>> fizzbuzz(5, fizz=3, buzz=5)
102 'buzz'
103 >>> fizzbuzz(3, fizz=3, buzz=5)
104 'fizz'
105 >>> fizzbuzz(15, fizz=3, buzz=5)
106 'fizzbuzz'
107 >>> fizzbuzz(4, fizz=3, buzz=5)
108 4
109 >>> fizzbuzz(4, fizz=4, buzz=6)
Expected:
fizz
Got:
4
/home/bernat/code/perso/python-script/fizzbuzz.py:109: DocTestFailure
========================== 1 failed in 0.02 seconds ==========================
```
Модульные тесты можно писать и в виде обычного кода. Представим, что нам нужно протестировать следующую функцию:
```
def main(options):
"""Compute a fizzbuzz set of strings and return them as an array."""
logger.debug("compute fizzbuzz from {} to {}".format(options.start,
options.end))
return [str(fizzbuzz(i, options.fizz, options.buzz))
for i in range(options.start, options.end+1)]
```
В конце скрипта добавим следующие модульные тесты, использующие возможности `pytest` по использованию [параметризованных тестовых функций](https://docs.pytest.org/en/latest/parametrize.html):
```
# Модульные тесты
import pytest # noqa: E402
import shlex # noqa: E402
@pytest.mark.parametrize("args, expected", [
("0 0", ["fizzbuzz"]),
("3 5", ["fizz", "4", "buzz"]),
("9 12", ["fizz", "buzz", "11", "fizz"]),
("14 17", ["14", "fizzbuzz", "16", "17"]),
("14 17 --fizz=2", ["fizz", "buzz", "fizz", "17"]),
("17 20 --buzz=10", ["17", "fizz", "19", "buzz"]),
])
def test_main(args, expected):
options = parse_args(shlex.split(args))
options.debug = True
options.silent = True
setup_logging(options)
assert main(options) == expected
```
Обратите внимание на то, что, так как код скрипта завершается вызовом `sys.exit()`, при его обычном вызове тесты выполняться не будут. Благодаря этому `pytest` для запуска скрипта не нужен.
Тестовая функция будет вызвана по одному разу для каждой группы параметров. Сущность `args` используется в качестве входных данных для функции `parse_args()`. Благодаря этому механизму мы получаем то, что нужно передать функции `main()`. Сущность `expected` сравнивается с тем, что выдаёт `main()`. Вот что сообщит нам `pytest` в том случае, если всё работает так, как ожидается:
```
$ python3 -m pytest -v --doctest-modules ./fizzbuzz.py
============================ test session starts =============================
platform linux -- Python 3.7.4, pytest-3.10.1, py-1.8.0, pluggy-0.8.0 -- /usr/bin/python3
cachedir: .pytest_cache
rootdir: /home/bernat/code/perso/python-script, inifile:
plugins: xdist-1.26.1, timeout-1.3.3, forked-1.0.2, cov-2.6.0
collected 7 items
fizzbuzz.py::fizzbuzz.fizzbuzz PASSED [ 14%]
fizzbuzz.py::test_main[0 0-expected0] PASSED [ 28%]
fizzbuzz.py::test_main[3 5-expected1] PASSED [ 42%]
fizzbuzz.py::test_main[9 12-expected2] PASSED [ 57%]
fizzbuzz.py::test_main[14 17-expected3] PASSED [ 71%]
fizzbuzz.py::test_main[14 17 --fizz=2-expected4] PASSED [ 85%]
fizzbuzz.py::test_main[17 20 --buzz=10-expected5] PASSED [100%]
========================== 7 passed in 0.03 seconds ==========================
```
Если произойдёт ошибка — `pytest` даст полезные сведения о том, что случилось:
```
$ python3 -m pytest -v --doctest-modules ./fizzbuzz.py
[...]
================================== FAILURES ==================================
__________________________ test_main[0 0-expected0] __________________________
args = '0 0', expected = ['0']
@pytest.mark.parametrize("args, expected", [
("0 0", ["0"]),
("3 5", ["fizz", "4", "buzz"]),
("9 12", ["fizz", "buzz", "11", "fizz"]),
("14 17", ["14", "fizzbuzz", "16", "17"]),
("14 17 --fizz=2", ["fizz", "buzz", "fizz", "17"]),
("17 20 --buzz=10", ["17", "fizz", "19", "buzz"]),
])
def test_main(args, expected):
options = parse_args(shlex.split(args))
options.debug = True
options.silent = True
setup_logging(options)
assert main(options) == expected
E AssertionError: assert ['fizzbuzz'] == ['0']
E At index 0 diff: 'fizzbuzz' != '0'
E Full diff:
E - ['fizzbuzz']
E + ['0']
fizzbuzz.py:160: AssertionError
----------------------------- Captured log call ------------------------------
fizzbuzz.py 125 DEBUG compute fizzbuzz from 0 to 0
===================== 1 failed, 6 passed in 0.05 seconds =====================
```
В эти выходные данные включён и вывод команды `logger.debug()`. Это — ещё одна веская причина для использования в скриптах механизмов логирования. Если вы хотите узнать подробности о замечательных возможностях `pytest` — взгляните на [этот](https://vincent.bernat.ch/en/blog/2016-testing-pytest-linux-namespaces) материал.
Итоги
-----
Сделать Python-скрипты надёжнее можно, выполнив следующие четыре шага:
* Оснастить скрипт документацией, размещаемой в верхней части файла.
* Использовать модуль `argparse` для документирования параметров, с которыми можно вызывать скрипт.
* Использовать модуль `logging` для вывода сведений о процессе работы скрипта.
* Написать модульные тесты.
[Вот](https://github.com/vincentbernat/python-script/blob/master/fizzbuzz.py) полный код рассмотренного здесь примера. Вы можете использовать его в качестве шаблона для собственных скриптов.
Вокруг этого материала развернулись интересные обсуждения — найти их можно [здесь](https://lobste.rs/s/zoo6tm/sustainable_python_scripts) и [здесь](https://www.reddit.com/r/programming/comments/cfn9vz/sustainable_python_script/). Аудитория, как кажется, хорошо восприняла рекомендации по документации и по аргументам командной строки, а вот то, что касается логирования и тестов, показалось некоторым читателям «пальбой из пушки по воробьям». [Вот](https://www.madmode.com/2019/python-eng.html) материал, который был написан в ответ на данную статью.
**Уважаемые читатели!** Планируете ли вы применять рекомендации по написанию Python-скриптов, данные в этой публикации?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/462007/ | null | ru | null |
# Снижаем время простоя при обновлении Zimbra
К таким преимуществам Zimbra Collaboration Suite Open-Source Edition, как надежность, высокое быстродействие, а также бесплатность решения, следует отнести еще и достаточно частое появление свежих версий Zimbra и регулярное добавление в них востребованных сообществом функций. Так, например, только за последний год были добавлены такие функции как возможность самостоятельного восстановления пароля пользователем, возможность смены календаря по умолчанию, поддержка иерархических адресных книг и прочие полезные для бизнеса возможности. Впрочем, исторически так сложилось, что ИТ-менеджеры в России не особо любят обновления.
Старое как мир правило о том, что не стоит трогать то, что и так прекрасно работает, прочно засело в головы российских ИТ-шников еще в конце 90-ых годов. И действительно, ломающие стабильность работы решений обновления, а также резкие смены интерфейсов, которые вводили в ступор пользователей, были обычным делом в то время. Однако новые времена бросают ИТ-менеджерам новые вызовы и сейчас подход в стиле «не трогай то, что и так работает», попросту неприменим. Информация об обнаружении уязвимостей сейчас разлетается по миру так быстро, а армии киберзлоумышленников пишут эксплоиты для этих уязвимостей с такой скоростью, что использование устаревших версий программного обеспечения на предприятии сопряжено с гигантскими рисками для информационной безопасности. И особенно эти риски велики в тех случаях, когда речь идет о платформах для совместной работы.
Еще один типичный аргумент против регулярного обновления информационных систем на предприятиях — необходимость приостановки их работы на время установки апдейтов. И такой аргумент действительно является решающим для крупных предприятий и SaaS-провайдеров, для которых важна близкая 100% доступность сервиса. Именно поэтому каждый разработчик при проектировании и разработке своего решения старается минимизировать или вовсе свести к нулю время простоя программного решения при его обновлении. Не являются исключением и разработчики Zimbra.
В настоящее время обновить Zimbra Collaboration Suite на предприятии без простоя самой информационной системы можно, но на деле этот процесс окажется бесшовной миграцией с одного сервера Zimbra на другой, где уже установлена более свежая версия ZCS с помощью Zextras Suite. Этот процесс уже был нами описан в одной из предыдущих статей. Те все же, кто не готов выделять дополнительные серверные мощности для миграции, могут воспользоваться рядом советов для уменьшения времени простоя Zimbra в процессе обновления.
Сам процесс обновления представляет из себя повторение процесса установки Zimbra с использованием более новой версии дистрибутива. Иными словами, достаточно просто скачать с сайта [Zimbra.com](http://zimbra.com) свежую версию ZCS, и при запуске установки программа самостоятельно обнаружит на сервере установленную Zimbra, после чего предложит обновить ее. В большинстве ситуаций обновление происходит в автоматическом режиме, но в случае, если вы обновляетесь с Zimbra версии 8.6 и старше, то вам может понадобиться доустановить модули memcached и zimbra-proxy, которые стали обязательными для установки, начиная с версии Zimbra 8.7.
Каких-либо советов по оптимизации времени на обновление Zimbra для тех, кто использует решение в односерверном варианте, нет. Обычно такие варианты установки используются на небольших предприятиях, которые могут позволить себе перерыв в работе системы совместной работы, особенно если запланировать обновление Zimbra на вечер или на ночь.
Что касается мультисерверной установки Zimbra, то здесь есть несколько приемов для сокращения времени простоя информационной системы. В первую очередь это касается порядка установки обновлений. Так, в первую очередь следует обновить сервер с LDAP. В том случае, если в вашей компании помимо основного LDAP есть серверы с LDAP Replica, то для избежания длительного простоя во время их обновления вы можете «повысить» один из LDAP Replica до LDAP Master, одновременно с этим с помощью брандмауэра запретив подключения к настоящему LDAP Master. Если же в вашей инфраструктуре всего один сервер LDAP, то избежать длительного простоя во время его обновления можно с помощью создания виртуального сервера LDAP Replica. После того как LDAP Master будет обновлен, можно будет вновь ввести его в работу, а затем обновить остальные LDAP-серверы.
Следующие на очереди серверы с Zimbra MTA и Zimbra Proxy. Если вы обновляетесь со старых версий Zimbra, то после обновления серверов c MTA не лишним будет выполнить следующие команды в интерфейсе командной строки для того, чтобы настройки по умолчанию были верными:
```
zmprov mcf zimbraMtaCommandDirectory /opt/zimbra/common/sbin
zmprov mcf zimbraMtaDaemonDirectory /opt/zimbra/common/libexec
zmprov mcf zimbraMtaMailqPath /opt/zimbra/common/sbin/mailq
zmprov mcf zimbraMtaManpageDirectory /opt/zimbra/common/share/man
zmprov mcf zimbraMtaNewaliasesPath /opt/zimbra/common/sbin/newaliases
zmprov mcf zimbraMtaSendmailPath /opt/zimbra/common/sbin/sendmail
```
Лишь после того как все узлы с LDAP, MTA и Proxy обновлены, можно приступать к обновлению почтовых хранилищ. Как и все предыдущие, серверы с почтовыми ящикам следует обновлять по одному. Избежать недоступности почтовых ящиков поможет функция doMoveMailbox, которая вшита в зимлет Zextras Powerstore и позволяет переносить ящики пользователей с одного почтового хранилища на другое в рамках одной инфраструктуры. Так, например, команда **zxsuite powerstore doMoveMailbox -a user@company.ru -f mailstore1.company.ru -t mailstore2.company.ru sync** перенесет ящик пользователя **user@company.ru** с первого почтового хранилища на второе, оставив соответствующую запись в LDAP. После этого следует удалить почтовый ящик со старого сервера с помощью команды вида **zmpurgeoldmbox -a user@company.ru -s mailstore1.company.ru**. А уже после завершения обновления почтового хранилища можно совершить перенос в обратном направлении, чтобы все вернулось к исходному состоянию. Отметим, что при желании и наличии полного перечня почтовых ящиков, располагавшихся в почтовом хранилище можно автоматизировать процесс переноса почтовых ящиков на новый сервер и обратно. Также с помощью команды **doMoveMailbox** можно избежать недоступности наиболее важных для предприятия почтовых ящиков.
После того как будут обновлены все почтовые хранилища, процесс обновления мультисерверной установки Zimbra можно считать завершенным. Заметного для пользователей простоя, если вы использовали команду **doMoveMailbox** для всех почтовых ящиков, практически удалось избежать.
По всем вопросам, связанными c Zextras Suite вы можете обратиться к Представителю компании «Zextras» Екатерине Триандафилиди по электронной почте ekaterina.triandafilidi@zextras.com | https://habr.com/ru/post/445206/ | null | ru | null |
# React v16.4.0: События указателей
Последний минорный релиз добавляет поддержку часто запрашиваемой фичи — событий указателей (*pointer events*)!
Также, он включает исправления для метода `getDerivedStateFromProps`. Полный список изменений доступен ниже.
События указателей
------------------
Появились следующие типы событий в React DOM:
* `onPointerDown`
* `onPointerMove`
* `onPointerUp`
* `onPointerCancel`
* `onGotPointerCapture`
* `onLostPointerCapture`
* `onPointerEnter`
* `onPointerLeave`
* `onPointerOver`
* `onPointerOut`
Обратите внимание, что эти события будут работать только в браузерах, поддерживающих спецификацию [событий указателей](https://developer.mozilla.org/en-US/docs/Web/API/Pointer_events). (На момент написания статьи к таким браузерам относятся Chrome, Firefox, Edge и Internet Explorer.) Если ваше приложение зависит от событий указателей, мы рекомендуем использовать сторонний полифил. Было решено не включать полифил в React DOM, чтобы не увеличивать размер итогового бандла.
Рекомендуем посмотреть [этот пример на CodeSandbox](https://codesandbox.io/s/q83r7nrwv6).
Огромное спасибо человеку по имени [Philipp Spiess](https://github.com/philipp-spiess) за работу над этим изменением!
Исправление для `getDerivedStateFromProps`
------------------------------------------
`getDerivedStateFromProps` теперь вызывается каждый раз при отрисовке компонента, вне зависимости от причины его изменения. До этого он вызывался только когда компонент перерисовывался его родителем и не срабатывал при вызове `setState` компонента. Это было упущение первоначальной реализации метода, и оно сейчас исправлено. Предыдущее поведение было более похоже на `componentWillReceiveProps`, но в его улучшенном состоянии обеспечивается совместимость с режимом асинхронного рендеринга, который скоро появится в React.
**Это исправление не повлияет на большинство приложений**, но может вызвать проблемы у небольшой доли компонентов. Те редкие случаи, когда это может случиться, попадают под одну из двух категорий:
1. **Избегайте побочных (*side*) эффектов в `getDerivedStateFromProps`**
Как и метод `render`, `getDerivedStateFromProps` должен быть чистой функцией, работающей только с пропсами и состоянием. Побочные эффекты никогда не поддерживались в `getDerivedStateFromProps`, но так как теперь он срабатывает чаще, чем раньше, это изменение может выявить необнаруженные ранее баги.
Код с побочными эффектами должен быть перенесен в другие методы: например, вызовы Flux-событий должны находиться непосредственно в обработчике событий, а манипуляции с DOM'ом должны производиться в `componentDidMount` или `componentDidUpdate`. Почитайте нашу недавнюю статью на тему [подготовки к асинхронному рендерингу](https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html).
2. Сравнивайте новые пропсы с предыдущими при вычислении контролируемых значений
Следующий кусок кода предполагает, что `getDerivedStateFromProps` вызовется при изменении пропсов:
```
static getDerivedStateFromProps(props, state) {
if (props.value !== state.controlledValue) {
return {
// Так как этот метод срабатывает при изменении и пропсов, и состояния,
// изменение controlledValue через setState будет игнорироваться, потому что значение из пропсов всегда будет перезаписывать его. Та-дам!
controlledValue: props.value,
};
}
return null;
}
```
Один из возможных способов решения — это сравнивать новое значение с предыдущим, сохраняя предыдущее в состояние:
```
static getDerivedStateFromProps(props, state) {
const prevProps = state.prevProps;
// Сравниваем новый пропс со старым
const controlledValue =
prevProps.value !== props.value
? props.value
: state.controlledValue;
return {
// Сохраняем старые пропсы в состоянии
prevProps: props,
controlledValue,
};
}
```
Однако, старайтесь избегать смешивания пропсов и состояния таким образом — довольно редко случается так, что состояние должно дублировать значение из пропсов, и такая практика может привести к неявным багам. Желательно иметь единый верный источник для любого значения и по возможности [передавать сосотяние вышестоящему компоненту](https://reactjs.org/docs/lifting-state-up.html) для использования в других компонентах. Большинство случаев использования `getDerivedStateFromProps` (и его предшественника `componentWillReceiveProps`) решается перенесением управления сосотянием в вышестоящий компонент.
Важно помнить, что **большинству компонентов не требуется `getDerivedStateFromProps`**. Он не задумывался как точная замена `componentWillReceiveProps`. В ближайшие недели мы выложим пост с рекомендациями по тому, как использовать (и не использовать) `getDerivedStateFromProps`.
---
[Полный список изменений](https://reactjs.org/blog/2018/05/23/react-v-16-4.html#changelog) (*Сhangelog*)
---
P.S. Если вы хотели бы увидеть какой-то перевод из мира React пишите в личку или [telegram](https://t.me/maxfarseer)/[vk](https://vk.com/maxpfrontend) | https://habr.com/ru/post/359264/ | null | ru | null |
# Работа с изображениями на Python
Тема сегодняшнего разговора — чему же научился Python за все годы своего существования в работе с изображениями. И действительно, кроме старичков родом из 1990 года ImageMagick и GraphicsMagick, есть современные эффективные библиотеки. Например, Pillow и более производительная Pillow-SIMD. Их активный разработчик Александр Карпинский ([homm](https://habr.com/ru/users/homm/)) на MoscowPython сравнил разные библиотеки для работы с изображениями на Python, представил бенчмарки и рассказал о неочевидных особенностях, которых всегда хватает. В этой статье расшифровка доклада, который поможет вам выбрать библиотеку под свое приложение, и сделать так, чтобы она работало максимально эффективно.
**О спикере:** Александр Карпинский работает в компании [Uploadcare](https://uploadcare.com/) и занимается сервисом быстрой модификации изображений на лету. Участвует в разработке [Pillow](https://python-pillow.org/) — популярной библиотеки для работы с изображениями на Python, развивает собственный форк этой библиотеки — [Pillow-SIMD](https://github.com/uploadcare/pillow-simd), который использует современные инструкции процессоров для наибольшей производительности.
Бэкграунд
---------
Сервис модификации изображений в Uploadcare — это сервер, к которому приходит HTTP-запрос с идентификатором изображения и какими-то операциями, которые нужно выполнить клиенту. Сервер должен выполнить операции и как можно быстрее отдать ответ. В качестве клиента чаще всего выступает браузер.
Весь сервис можно описать как обертку вокруг графической библиотеки. Именно от качества, производительности и удобства использования графической библиотеки зависит качество всего проекта. Несложно догадаться, что в качестве графической библиотеки в Uploadcare используется Pillow.
Библиотеки
----------
Кратко рассмотрим, какие вообще есть в Python библиотеки для работы с графикой, чтобы лучше понимать, о чем пойдет речь далее.
### Pillow
[Pillow](https://python-pillow.org/) — форк PIL (Python Imaging Library). Это очень старый проект, вышедший в 1995 году для Python 1.2. Можно представить, насколько он старый! В какой-то момент Python Imaging Library была заброшена, ее разработка прекратилась. Форк Pillow был сделан для того, чтобы устанавливать и собирать Python Imaging Library на современных системах. Постепенно количество изменений, которые нужны были людям в Python Imaging Library росло, и вышла Pillow 2.0, в которую была добавлена поддержка Python 3. Это можно считать началом отдельной жизни проекта Pillow.
Pillow представляет из себя нативный модуль для Python, половина кода написана на С, половина — на Python. Версии Python поддерживаются самые разнообразные: 2.7, 3.3+, PуPу, PуPуЗ.
### Pillow-SIMD
Это мой форк Pillow, который выходит с мая 2016 года. SIMD означает Single Instruction, Multiple Data— подход, при котором процессор может выполнять большее количество действий на такт, используя современные инструкции.
[Pillow-SIMD](https://github.com/uploadcare/pillow-simd) — это не форк в классическом понимании, когда проект начинает жить собственной жизнью. Это замена Pillow, то есть вы устанавливаете одну библиотеку вместо другой, ни строчки не меняете в своем исходном коде, и получаете большую производительность.
Pillow-SIMD можно собирать с инструкциями SSE4 (по умолчанию). Это набор инструкций, который есть практически во всех современных x86 процессорах. Также Pillow-SIMD можно собирать с набором инструкций AVX2. Этот набор инструкций есть, начиная с архитектуры Haswell, то есть примерно с 2013 года.
### OpenCV
Другая библиотека для работы с изображениями в Python, о которой вы наверняка слышали — это [OpenCV](https://opencv.org/) (Open Computer Vision). Работает с 2000 года. Биндинг на Python входит в комплект. Это означает, что биндинг постоянно актуален, не бывает рассинхронности между самой библиотекой и биндингом.
К сожалению, эта библиотека пока не поддерживается в PyPy, потому что OpenCV базируется на numpy, а numpy только недавно стал работать под PyPy, и в OpenCV поддержки PyPy все еще нет.
### VIPS
Еще одна библиотека, на которую стоит обратить внимание — VIPS. Основная идея [VIPS](https://d.docs.live.net/5f198da7c280adbc/%D0%94%D0%BE%D0%BA%D1%83%D0%BC%D0%B5%D0%BD%D1%82%D1%8B/HighLoad/%D0%A0%D0%B0%D1%81%D1%88%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B8/icupitt.qithub.io/Libvips/) в том, что для работы с изображением не нужно загружать всё изображение в память. Библиотека может загружать какие-то маленькие кусочки, обрабатывать их и сохранять. Таким образом, для обработки гигапиксельных изображений не нужно тратить гигабайты памяти.
Это довольно старая библиотека — 1993 года, но она обогнала своё время. О ней долгое время было мало, что слышно, но в последнее время для VIPS стали появляться биндинги под разные языки, в том числе для Go, Node.js, Ruby.
Я долгое время хотел попробовать эту библиотеку, пощупать, но мне это не удавалось по очень глупой причине. Я не мог разобраться, как установить VIPS, потому что биндинг собирался очень сложно. Но теперь (в 2017 году) вышел биндинг pyvips от автора самого VIPS, с которым уже нет никаких проблем. Теперь установка и использование VIPS очень простая. Поддерживаются: Python 2.7, 3.3+, PуPу, PуPуЗ.
### ImageMagick & GraphicsMagick
Если говорить о работе с графикой, то нельзя не упомянуть старичков — библиотеки [ImageMagick](http://imagemagick.org/script/index.php) и [GraphicsMagick](http://www.graphicsmagick.org/). Последняя изначально была форком ImageMagick с большей производительностью, но сейчас производительность у них, кажется, сравнялась. Других принципиальных отличий, насколько я знаю, между ними нет. Поэтому можно использовать любую, точнее, ту, которую вам удобнее использовать.
Это самые старые библиотеки из тех, о которых я сегодня упомянул (1990 год). За все это время было несколько биндингов для Python, и почти все из них благополучно умерли к настоящему моменту. Из тех, что можно использовать, остались:
* Биндинг Wand, который построен на ctypes, но уже тоже не обновляется.
* Биндинг pgmagick использует Boost.Python, поэтому компилируется очень долго и не работает в PyPy. Но, тем не менее, использовать его можно, я бы сказал, что он предпочтительнее, чем Wand.
Производительность
------------------
Когда мы говорим о работе с изображениями, первое, что нам интересно (по крайней мере мне) — это производительность, потому что иначе мы бы могли и на Python написать что-нибудь руками.
Производительность — это не такая простая штука. Нельзя просто сказать, что одна библиотека работает быстрее другой. В каждой библиотеке есть набор функций, и каждая функция работает с разной скоростью.
Соответственно, корректно говорить только о том, что производительность одной функции выше или ниже в конкретной библиотеке. Либо у вас есть приложение, которому нужен некий набор функциональности, и вы делаете бенчмарк именно под эту функциональность, и говорите, что для вашего приложения такая-то библиотека работает быстрее (медленнее).
### Важно проверять результат
Когда вы делаете бенчмарки, очень важно смотреть на результат, который получается. Даже если с первого взгляда вы написали один и тот же код, это не значит, что он одинаковый.
Недавно в статье, где сравнивалась производительность Pillow и OpenCV, мне попался такой код:
```
from PIL import Image, ImageFilter.BoxBlur
im.filter(ImageFilter.BoxBlur(3))
...
import cv2
cv2.blur(im, ksize=(3, 3))
...
```
Вроде бы и там, и там, BoxBlur, и там, и там аргумент 3, но на самом деле результат разный. Потому что в Pillow (3) — это радиус размытия, а в OpenCV ksize=(3, 3) — это размер ядра, то есть, грубо говоря, диаметр. В данном случае корректное значение для OpenCV было бы 3\*2+1, то есть (7, 7).
### В чем проблема?
Почему вообще производительность — это проблема при работе с графикой? Потому что сложность любой операций зависит от нескольких параметров, и чаще всего сложность растет линейно с каждым из них. А если этих факторов, например, три, и сложность линейно зависит от каждого, то получается сложность в кубе.
**Пример:** Гауссово размытие в OpenCV.
Слева — радиус 3, справа — 30. Как видно, разница в скорости более чем в 10 раз.
Когда передо мной встала задача добавить размытие по Гауссу в мое приложение, меня не устраивало, что гипотетически может тратиться 900 мс на выполнение одной операции. Таких операций в приложении тысячи в минуту, и тратить столько времени на одну — нецелесообразно. Поэтому я изучил вопрос и реализовал в Pillow размытие по Гауссу, которое работает за константное время относительно радиуса. То есть на производительность Гауссова размытия влияет только размер картинки.
Но здесь главное не то, что что-то работает быстрее или медленнее.
> Я хочу донести, что, когда вы строите какую-то систему, важно понимать, от каких параметров зависит сложность на выходе. Тогда вы сможете ограничить эти параметры или другими способами бороться с этой сложностью.
>
>
Наверное, самая частая операция, которую мы делаем с изображениями после их открытия, — это изменение размера (resize).
На графике представлена производительность (больше — лучше) разных библиотек для операции уменьшения изображения в 8 и в 1,25 раз.
Для PIL результат 17 Mpx/s означает, что фотографию с айфона (12 Mpx) можно уменьшить в 1,25 раз чуть меньше, чем за секунду. Такой производительности недостаточно для серьезного приложения, которое этих операций выполняет очень много.
Я стал оптимизировать производительность ресайза, и в Pillow 2.7 мне удалось добиться двукратного прироста производительности, а в Pillow 4.3 — трехкратного (на данный момент актуальна версия Pillow 5.3, но производительность ресайза в ней та же).
Но операция ресайза — это такая штука, которая очень хорошо ложится на SIMD. Она подходит к single instruction, multiple data, и поэтому в текущей версии Pillow-SIMD мне удалось **в 19 раз увеличить скорость ресайза** по сравнению с оригинальной Python Imaging Library при использовании тех же самых ресурсов.
Это существенно выше производительности ресайза в OpenCV. Но сравнение это не совсем корректное, потому что в OpenCV используется чуть менее качественный способ ресайза бокс-фильтром, а в Pillow-SIMD ресайз реализован с помощью сверток.
Это неполный список тех операций, которые ускорены в Pillow-SIMD по сравнению с обычной Pillow.
* Ресайз: от 4 до 7 раз.
* Размытие: 2,8 раз.
* Применение ядра 3×3 или 5×5: 11 раз.
* Умножение и деление на альфа-канал: 4 и 10 раз.
* Альфа-композиция: 5 раз.
Я уже сказал, что нельзя говорить, что какая-то библиотека работает быстрее, чем другая, но можно составить какой-то набор операций, который интересен именно вам. Я выбрал набор операций, которые интересны в моем приложении, сделал бенчмарк и получил такие результаты.
Оказалось, что Pillow-SIMD на этом наборе работает в 2 раза быстрее, чем Pillow. В самом конце находится Wand (напомню, что это ImageMagick).
Но меня заинтересовало другое — почему такие низкие результаты у OpenCV и VIPS, ведь это библиотеки, которые тоже разработаны с прицелом на производительность? Оказалось, что в случае OpenCV, та бинарная сборка OpenCV, которая ставится с помощью pip, собрана с медленным кодеком JPEG (автор сборки был уведомлен, на 2018 год эта проблема уже решена). Она собрана с libjpeg, в то время как в большинстве систем, по крайней мере debian-based, используется libjpeg-turbo, которая работает в несколько раз быстрее. Если собрать OpenCV из исходников самому, то производительность будет больше.
В случае VIPS ситуация другая. Я связался с автором VIPS, показал ему этот бенчмарк, мы с ним довольно долго и плодотворно переписывались. После чего автор VIPS нашел несколько мест в самом VIPS, где исполнение было не по оптимальному маршруту, и исправил их.
Вот что будет с производительностью, если собрать OpenCV из исходников текущей версии, а VIPS — из master, который уже есть сейчас.
> Даже если вы нашли какой-то бенчмарк, еще не факт, что все будет работать именно с такой скоростью именно на вашей машине.
>
>
### Набор бенчмарков
Все бенчмарки, о которых я рассказал, можно найти на [странице с результатами](http://python-pillow.org/pillow-perf/). Это отдельный мини-проект, где я пишу бенчмарки, которые мне самому нужны для разработки Pillow-SIMD, запускаю их и выкладываю результаты.
На GitHub есть [проект](https://github.com/python-pillow/pillow-perf) с фреймворками для тестирования, где каждый может предложить свои бенчмарки или поправить существующие.
Параллельная работа
-------------------
До сих пор я говорил о производительности в чистом виде, то есть на одно ядро процессора. Но нам всем давно доступны системы с бо́льшим количеством ядер, и хотелось бы их утилизировать. Здесь я должен сказать, что на самом деле Pillow — это единственная из всех рассматриваемых библиотек, которая не использует распараллеливание задач. Я сейчас постараюсь объяснить, почему так происходит. Все остальные библиотеки в том или ином виде его используют.
### Метрики производительности
С точки зрения производительности нам интересны 2 параметра:
1. **Реальное время выполнения одной операции.** Есть операция (либо последовательность операций), и вам интересно, за какое реальное время (wall clock) выполнится эта последовательность. Этот параметр важен на десктопе, где есть пользователь, который отдал команду и ждет результат.
2. **Пропускная способность всей системы** (потока операций). Когда у вас есть набор операций, который идет постоянно, либо много независимых операций, и вам важна скорость обработки этих операций на вашем железе. Эта метрика более важна на сервере, где клиентов много, и нужно обслужить их всех. Время обслуживания одного клиента, конечно, важно, но чуть меньше, чем общая пропускная способность.
Исходя из этих двух метрик рассмотрим разные способы параллельной работы.
### Способы параллельной работы
1. **На уровне приложения**, когда вы на уровне приложения решаете, что операции обрабатываются в разных потоках. При этом реальное время выполнения одной операции не меняется, потому что по-прежнему одно ядро занимается одной последовательностью операций. Пропускная способность системы растет пропорционально количеству ядер, то есть очень хорошо.
2. **На уровне графических операций** — то, что как раз есть в большинстве графических библиотек. Когда графическая библиотека получает какую-то операцию, она внутри себя создает необходимое количество потоков, разбивает одну операцию на несколько более мелких, и выполняет их. При этом реальное время выполнения уменьшается — одна операция выполняется быстрее. Но **пропускная способность растет далеко не линейно** от количества ядер. Есть операции, которые не параллелятся, и яркий пример — это декодирование PNG-файлов — его никак нельзя распараллелить. Кроме того, есть накладные расходы на создание потоков, разбиение задач, которые тоже не дают пропускной способности расти линейно.
3. **На уровне команд процессора и данных**. Мы специальным образом подготавливаем данные и используем специальные команды, для того чтобы процессор работал с ними быстрее. Это подход SIMD, который, собственно, и используется в Pillow-SIMD. Реальное время выполнения уменьшается, пропускная способность растет — **это беспроигрышный вариант**.
### Как совместить параллельную работу
Если мы хотим совместить как-то параллельную работу, то SIMD хорошо совмещается с распараллеливанием внутри операции, и SIMD хорошо совмещается с распараллеливанием внутри приложения.
Но распараллеливание внутри приложения и внутри операции друг с другом не совмещаются. Если вы попробуете это сделать, то получите минусы от обоих подходов. Реальное время выполнения операции будет таким же, каким оно и было на одном ядре, а пропускная способность системы вырастет, но не линейно относительно количества ядер.
### Многопоточность
Если уж мы заговорили про потоки — мы все пишем на Python и знаем, что в нем есть GIL, который не дает выполняться двум потокам одновременно. Python — это строго однопоточный язык.
Конечно, это не правда, потому что GIL на самом деле не дает выполняться двум потокам на Python, а если код написан на другом языке, и во время своей работы не использует внутренние структуры Python, то этот код может отпускать GIL и таким образом освобождать интерпретатор под другие задачи.
Многие библиотеки для работы с графикой освобождают GIL во время своей работы, в том числе Pillow, OpenCV, pyvips, Wand. Не освобождает только одна — pgmagick. То есть вы можете спокойно создавать потоки под выполнение каких-то операций, и это будет работать параллельно с остальным кодом.
Но возникает вопрос: **сколько создавать потоков?**
Если мы будем создавать бесконечное количество потоков под каждую задачу, которая у нас есть, то они просто займут всю память и весь процессор, — мы не получим никакой эффективной работы. Я сформулировал специальное правило.
> **Правило N + 1**
>
>
>
> Для продуктивной работы нужно создавать не более N + 1 воркеров, где N — количество ядер или потоков процессора на машине, а воркер — это процесс или поток, занятый обработкой.
>
>
Лучше всего использовать именно процессы, потому что даже в рамках одного интерпретатора есть узкие места и накладные расходы.
Например, у нас в приложении используется N + 1 instance Tornado, балансировку между которыми осуществляет ngnix. Если упомянуто Tornado, то давайте поговорим об асинхронной работе.
Асинхронная работа
------------------
То время, которое графическая библиотека занимается собственно полезной работой — обработкой изображений — можно и нужно использовать для ввода/вывода, если они есть у вас в приложении. Асинхронные фреймворки здесь очень в тему.
Но есть проблема — когда мы вызываем какую-то обработку, она вызывается синхронно. Даже если библиотека отпускает в этот момент GIL, все равно Event Loop блокируется.
```
@gen.coroutine
def get(self, *args, **kwargs):
im = process_image(...)
...
```
К счастью, эту проблему очень легко решить созданием ThreadPoolExecutor с одним тредом, на котором запускается обработка изображения. Этот вызов уже происходит асинхронно.
```
@run_on_executor(executor=ThreadPoolExecutor(1))
def process_image(self,
...
@gen.coroutine
def get(self, *args, **kwargs):
im = yield process_image(...)
...
```
По сути здесь создается очередь с одним воркером, который выполняет именно графические операции, а Event Loop не блокируется и спокойно работает параллельно в другом потоке.
Ввод/Вывод
----------
Еще одна тема, которую я бы хотел затронуть в рамках разговора о графических операциях — это ввод/вывод. Дело в том, что мы редко создаем какие-то изображения с помощью графической библиотеки. Чаще всего мы открываем изображения, которые пришли к нам от пользователей в виде закодированных файлов (JPEG, PNG, BMP, TIFF и пр.).
Соответственно, графическая библиотека для построения хорошего приложения должна обладать некоторыми плюшками по вводу/выводу именно из файлов.
### Ленивая загрузка
Первая такая плюшка — это ленивая загрузка. Если, например, в Pillow вы открываете изображение, то в этот момент не происходит декодирования картинки. Вам возвращается объект, который выглядит, как будто изображение уже загружено и работает. Вы можете посмотреть его свойства и решить на основании свойств этого изображения, готовы ли вы с ним работать дальше, не загрузил ли вам пользователь, например, гигапиксельную картинку для того, чтобы сломать ваш сервис.
```
>>> from PIL import Image
>>> %time im = Image.open()
Wall time: 1.2 ms
>>> im.mode, im.size
('RGB', (2152, 1345))
```
Если вы принимаете решение, что дальше работаете, то с помощью явного или неявного вызова load происходит декодирование этого изображения. Уже в этот момент выделяется нужное количество памяти.
```
>>> from PIL import Image
>>> %time im = Image.open()
Wall time: 1.2 ms
>>> im.mode, im.size
('RGB', (2152, 1345))
>>> %time im.load()
Wall time: 73.6 ms
```
### Режим битых картинок
Вторая плюшка, которая нужна при работе с пользовательским контентом — это режим битых картинок. Файлы, которые мы получаем от пользователей, очень часто содержат какие-то несоответствия с форматом, в котором они закодированы.
Эти несоответствия бывают по разным причинам. Иногда это ошибки передачи по сети, иногда — просто какие-то кривые кодеки, которыми кодировалось изображение. По умолчанию Pillow, когда видит изображения, которые не соответствуют формату до конца, просто кидает исключение.
```
from PIL import Image
Image.open('trucated.jpg').save('trucated.out.jpg')
IOError: image file is truncated (143 bytes not processed)
```
Но пользователь же не виноват в том, что у него картинка битая, он все равно хочет получить результат. К счастью, у Pillow есть режим битых картинок. Мы меняем одну настройку, и Pillow старается по максимуму игнорировать все ошибки декодирования, которые есть в изображении. Соответственно, пользователь видит хотя бы что-то.
```
from PIL import Image, ImageFile
ImageFile.LOAD_TRUNCATED_IMAGES = True
Image.open('trucated.jpg').save('trucated.out.jpg')
```
Даже обрезанная картинка — это все равно лучше, чем ничего — просто страница с ошибкой.
### Сводная таблица
В таблице выше я собрал все, что касается ввода/вывода в тех библиотеках, о которых я рассказываю. В частности, я посчитал количество кодеков различных форматов, которые есть в библиотеках. Получилось, что в OpenCV их меньше всех, в ImageMagick — больше всех. Похоже, что в ImageMagick можно открыть вообще любое изображение, которое вам встретится. У VIPS 12 собственных кодеков, но VIPS может использовать ImageMagick в качестве промежуточного звена. Я не проверял, как это работает, надеюсь, что бесшовно.
В Pillow 17 кодеков. Это сейчас единственная библиотека, в которой нет автоповорота EXIF. Но сейчас это небольшая проблема, потому что можно прочитать EXIF самому и повернуть изображение в соответствии с ним. Это вопрос небольшого сниппета, который легко гуглится и занимает максимум в 20 строчек.
### Особенности OpenCV
Если посмотреть на эту таблицу внимательно, то видно, что в OpenCV на самом деле не все так хорошо с вводом/выводом. В нем меньше всего кодеков, нет ленивой загрузки и нельзя прочитать EXIF и цветовой профиль.
Но это не все. На самом деле у OpenCV есть еще особенности. Когда мы просто открываем какую-то картинку, то вызов `cv2.imread(filename)` поворачивает JPEG-файлы в соответствии с EXIF (см. таблицу), но при этом игнорирует альфа-канал у PNG-файлов — довольно странное поведение!
К счастью, в OpenCV есть флаг: `cv2.imread(filename, flags=cv2.IMREAD_UNCHANGED)`.
Если указать флаг IMREAD\_UNCHANGED, то OpenCV оставляет альфа-канал у PNG-файлов, но перестает поворачивать JPEG-файлы в соответствии с EXIF. То есть один и тот же флаг влияет на два совершенно разных свойства. Как видно из таблицы, у OpenCV нет возможности прочитать EXIF, и получается, что в случае с этим флагом невозможно повернуть JPEG вообще.
Что делать, если вы заранее не знаете, какого формата у вас изображение, и вам нужны и альфа-канал у PNG, и автоповорот у JPEG? Ничего не сделать — OpenCV так не работает.
Причина, почему в OpenCV такие проблемы, кроется в названии этой библиотеки. В ней очень много функциональности для компьютерного зрения и анализа изображений. По сути, OpenCV рассчитана на работу с верифицированными источниками. Это, например, камера наружного наблюдения, которая раз в секунду скидывает изображения, и делает это в течение 5 лет в одном и том же формате и одном и том же разрешении. Здесь не нужна вариативность в вопросе ввода/вывода.
Людям, которым нужна функциональность OpenCV, не сильно нужна функциональность работы с пользовательским контентом.
Но что делать, если в вашем приложении все-таки нужна функциональность работы с пользовательским контентом, и в то же время нужна вся мощь OpenCV по обработке и статистике?
Решение в том, что нужно совмещать библиотеки. Дело в том, что OpenCV построен на базе numpy, и в Pillow есть все средства для того, чтобы экспортировать изображения из Pillow в массив numpy. То есть мы экспортируем массив numpy, и OpenCV может дальше работать с этим изображением, как со своим собственным. Это делается очень легко:
```
import numpy
from PIL import Image
...
pillow_image = Image.open(filename)
cv_image = numpy.array(pillow_image)
```
Дальше, когда мы делаем магию с помощью OpenCV (обработку), мы вызываем еще один метод Pillow и обратно импортируем из OpenCV картинку в формат Pillow. Соответственно, можно снова пользоваться вводом/выводом.
```
import numpy
from PIL import Image
...
pillow_image = Image.fromarray(cv_image, "RGB")
pillow_image.save(filename)
```
Таким образом получается, что мы пользуемся вводом/выводом от Pillow, и процессингом от OpenCV, то есть берем лучшее из двух миров.
Надеюсь, это поможет вам построить нагруженное приложение для работы с графикой.
> Узнать некоторые другие секреты разработки на Python, перенять бесценный и местами неожиданный опыт, а главное обсудить свои задачи можно будет уже совсем скоро на [Moscow Python Conf++](https://conf.python.ru/2018/). Например, обратите внимание на такие имена и темы в расписании.
>
>
>
> * Donald Whyte с историей о том, как с помощью популярных библиотек, хитрости и коварства делать математику в 10 раз быстрее, а код — понятным и поддерживаемым.
> * Андрей Попов про сбор огромного количества данных и их анализ на наличие угроз.
> * Ефрем Матосян в своем докладе «Make Python fast again» расскажет, как увеличить производительность демона, обрабатывающего сообщения из шины.
>
>
>
> Полной список того, что предстоит обсудить за 22 и 23 октября [тут](https://conf.python.ru/2018/abstracts/), успевайте присоединиться.
>
> | https://habr.com/ru/post/425471/ | null | ru | null |
# Возможные нововведения C#
[](http://habrahabr.ru/post/312048/)
Вы должно быть знаете, что в последнее время Microsoft старается общаться с сообществом, получать как можно больше отзывов и внедрять их в жизнь. Не обошла эта мода и команду разработчиков C#. Разработка новой версии языка определенно не идет за закрытыми дверями…
Статья Mads Torgersen под названием [What’s New in C# 7.0](https://blogs.msdn.microsoft.com/dotnet/2016/08/24/whats-new-in-csharp-7-0/) уже разобрана вдоль и поперек. Но есть что-то, что в ней не было упомянуто.
Предлагаю вам пройтись обзором по нескольким предложениям из репозитория Roslyn. Название темы [C# 7 Work List of Features](https://github.com/dotnet/roslyn/issues/2136). Информация обновлялась пару месяцев назад (то есть она не сильно актуальная), но это то, что определенно было не обделено вниманием Mads Torgersen.
Даже дважды, в рубриках Strong interest и Non-language упомянуты следующие предложения:
**1.** Enable code generating extensions to the compiler #5561
**2.** Add supersede modifier to enable more tool generated code scenarios #5292
Фактически, это предложение добавления в C# некоторого функционала аспектно-ориентированного программирования. Я постараюсь передать в сокращенном виде суть.
#### **Добавление генерирующего код расширения для компилятора**
Хотелось бы заметить, что на github это предложение помечено как находящееся в стадии разработки. Оно предлагает избавится от повторяющегося кода с помощью Code Injectors. При компиляции определенный код будет добавлен компилятором автоматически. Что важно: исходный код не будет изменен, а также внедрение кода будет происходить не после компиляции в бинарный файл.
В описании указано, что процесс написания инжектора будет похож на написание diagnostic analyzer. Я же надеюсь, что все будет гораздо проще (в таком случае классы можно будет создавать и редактировать вручную). Но, возможно, что это будет удобно делать только с помощью инструментов, которые генерируют код автоматически.
В качестве примера приведен класс, который в свою очередь внедряет в каждый класс проекта новое поле, — константу типа string с именем ClassName и значением, содержащим имя этого класса.
```
[CodeInjector(LanguageNames.CSharp)]
public class MyInjector : CodeInjector
{
public override void Initialize(InitializationContext context)
{
context.RegisterSymbolAction(InjectCodeForSymbol);
}
public void InjectCodeForSymbol(SymbolInjectionContext context)
{
if (context.Symbol.TypeKind == TypeKind.Class)
{
context.AddCompilationUnit($@"partial class {context.Symbol.Name}
{{ public const string ClassName = ""{context.Symbol.Name}""; }}");
}
}
}
```
Инжекторы кода изначально будут иметь возможность только добавить какой-нибудь код, но не изменить существующий. С их помощью можно будет избавиться от такой шаблонной логики, как, например, реализация INotifyPropertyChanged.
А как можно ускорить реализацию INotifyPropertyChanged сейчас? АОП фреймворк PostSharp фактически сделает это самое внедрение [Walkthrough: Automatically Implementing INotifyPropertyChanged](http://doc.postsharp.net/inotifypropertychanged-add)
В этом случае код реализации будет скрыт. Не ошибусь, если напишу, что некоторые изменения PostSharp совершает уже в после компиляции в коде IL ([How Does PostSharp Work](http://doc.postsharp.net/how-it-works)). Доподлинно известно, что эта утилита довольно продвинутая в плане изменения IL кода.
Но если компилятор будет иметь возможность распознать атрибут и добавить код самостоятельно до или во время компиляции, то это должно лучше сказаться на производительности и добавит возможность кастомизации.
Вот так выглядит простой класс, реализующий интерфейс INotifyPropertyChanged. Фактически в нем только одно свойство Name, но очень много лишнего кода реализации:
```
class Employee: INotifyPropertyChanged
{
private string _name;
public string Name
{
get { return _name; }
set
{
_name = value;
RaisePropertyChanged();
}
}
private void RaisePropertyChanged([CallerMemberName] string caller="")
{
if( PropertyChanged != null )
{
PropertyChanged(this, new PropertyChangedEventArgs(caller));
}
}
}
```
Все это можно будет заменить таким небольшим классом:
```
[INoifyPropertyChanged]
public class Employee
{
public string Name { get; set; }
}
```
Или, может быть, можно будет придумать свою конвенцию наименований и все классы в названии которых будет INPC будут реализовывать INoifyPropertyChanged. Получилось бы еще короче:
```
public class EmployeeINPC
{
public string Name { get; set; }
}
```
Но это я уже немного дал волю фантазии.
#### **Superseding members — замещение модификатора для того, чтобы дать больше возможностей инструментам генерации кода**
Эта фича разрешает членам класса переопределять члены этого же класса, замещая декларацию класса новой декларацией, используя модификатор supersede.
На примере должно быть понятнее, чем на словах:
```
// написанный пользователем код
public partial class MyClass
{
public void Method1()
{
// что-то чудесное здесь происходит
}
}
// код сгенерированный инструментом
public partial class MyClass
{
public supersede void Method1()
{
Console.WriteLine("entered Method1");
superseded();
Consolel.WriteLine("exited Method1");
}
}
```
В данном случае Method1, который был сгенерирован инструментом замещает Method1, который был написан пользователем. Все вызовы Method1 будут вызывать код созданный инструментом. Код, который создан инструментом может вызывать пользовательский код с помощью ключевого слова superseded. То есть, выходит, что в данном примере мы имеем автоматическое добавление логов в Method1.
Используя эту технику, реализация INotifyPropertyChanged может получиться такой вот:
```
// написанный пользователем код
public partial class MyClass
{
public int Property { get; set; }
}
// код сгенерированный инструментом
public partial class MyClass : INotifyPropertyChanged
{
public event PropertyChangedEventHandler PropertyChanged;
public supersede int Property
{
get { return superseded; }
set
{
if (superseded != value)
{
superseded = value;
var ev = this.PropertyChanged;
if (ev != null) ev(this, new PropertyChangedEventArgs("Property"));
}
}
}
}
```
Под ключевым словом superseded здесь уже фигурирует не метод, а свойство.
#### **Асинхронный Main**
Это предложение также помечено на github, как находящееся в стадии разработки. Внутри метода Main будет разрешено использование await. Делается это по причине того, что есть множество программ, внутри которых содержится подобная конструкция:
```
static async Task DoWork() {
await ...
await ...
}
static void Main() {
DoWork().GetAwaiter().GetResult();
}
```
В данном случае возможно прерывание работы программы по причине возникновения исключения. В случае же использования DoWork().Wait() любая возникшая ошибка будет преобразована в AggregateException.
Так как CLR не поддерживает асинхронные методы в качестве точек входа, то компилятор сгенерирует искусственный main метод, который будет вызывать пользовательский async Main.
Разработчикам зачастую требуется этот функционал и при реализации вручную они могут совершать ошибки. С этой точки зрения добавление этой фичи очевидный плюс. Минусом является то, что неопытные разработчики могут использовать асинхронность и там где нужно и там где ненужно.
---
Не факт, что эти фичи появятся в C# 7.0, и даже не факт, что они появятся в 8.0, но они определенно рассматривались командой разработчиков языка как потенциально интересные.
В [анонсе Visual Studio 2017](https://www.visualstudio.com/en-us/news/releasenotes/vs2017-relnotes) упоминается еще одно предложение [Task-like return types for async methods](https://github.com/dotnet/roslyn/issues/7169), которое точно будет в 7-ой версии языка.
Присоединяйтесь к обсуждению на GitHub или пишите комментарии здесь. | https://habr.com/ru/post/312048/ | null | ru | null |
# Как с помощью анализа геоданных предсказать количество вызовов экстренных служб в разных частях города?
Попробуйте решить задачу из онлайн-хакатона [Geohack.112](https://datasouls.com/c/mts-geohack/description). Дано: территория Москвы и Московской области была разделена на квадраты размеров от 500 на 500 метров. В качестве исходных данных представлено среднее количество вызовов экстренных служб в день (номера 112, 101, 102, 103, 104, 010, 020, 030, 040). Рассматриваемый регион был поделен на западную и восточную часть. Участникам предлагается, обучившись по западной части, предсказать количество вызовов экстренных служб для всех квадратов восточной.
В таблице **zones.csv** перечислены все квадраты с указанием их координат. Все квадраты расположены в Москве, либо на небольшом расстоянии от Москвы. Квадраты, расположенные в западной части выборки, предназначены для обучения модели — для этих квадратов известно среднее число вызовов экстренных служб из квадрата в день:
**calls\_daily**: по всем дням
**calls\_workday**: по рабочим дням
**calls\_weekend**: по выходным дням
**calls\_wd{D}**: по дню недели D (0 — понедельник, 6 — воскресенье)
На квадратах из восточной части выборки необходимо построить прогноз числа вызовов по всем дням недели. Оценка качества предсказания будет производиться по подмножеству квадратов, в которое не входят квадраты, откуда вызовы поступают крайне редко. Подмножество целевых квадратов имеет is\_target=1 в таблице. Для тестовых квадратов значения calls\_\* и is\_target скрыты.
На карте обозначены квадраты трех типов:
Зеленые — из обучающей части, не целевые
Красные — из обучающей части, целевые
Синие — тестовые, на них необходимо построить прогноз
В качестве решения необходимо предоставить CSV таблицу с предсказаниями для всех тестовых квадратов, для каждого квадрата — по всем дням недели.
Качество оценивается только по подмножеству целевых квадратов. Участникам неизвестно, какие из квадратов целевые, однако принцип выбора целевых квадратов в обучающей и тестовой части — идентичен. Во время соревнования качество оценивается на 30% тестовых целевых квадратов (выбраны случайно), в конце соревнования итоги подводятся по оставшимся 70% квадратов.
Метрика качества предсказаний — коэффициент ранговой корреляции [Kendall's Tau-b](https://en.wikipedia.org/wiki/Kendall_rank_correlation_coefficient#Tau-b), считается как доля пар объектов с неправильно упорядоченными предсказаниями с поправкой на пары с одинаковым значением целевой переменной. Метрика оценивает порядок, в котором предсказания соотносятся друг с другом, а не их точные значения. Разные дни недели считаются независимыми элементами выборки, т.е. коэффициент корреляции считается по предсказаниям для всех тестовых пар (zone\_id, день недели).
**Читаем таблицу квадратов при помощи Pandas**
```
import pandas
df_zones = pandas.read_csv('data/zones.csv', index_col='zone_id')
df_zones.head()
```
### Извлечение признаков из OpenStreetMap
Предсказание числа вызовов можно осуществить методами машинного обучения. Для этого каждому квадрату необходимо построить вектор с признаковым описанием. Обучив модель на размеченной западной части Москвы, ее можно будет использовать для предсказания целевой переменной в восточной части.
По условиям соревнования, данные для решения задачи можно брать из любых открытых источников. Когда речь идет об описании небольшой области на карте, первое что приходит в голову — OpenStreetMap, открытая некоммерческая электронная карта, которая создается руками сообщества.
Карта OSM представляет собой набор [элементов](https://wiki.openstreetmap.org/wiki/Elements) трех видов:
Node: точки на карте
Way: дороги, площади, задаются набором точек
Relation: связи между элементами, например объединение дороги из нескольких частей
Элементы могут иметь набор тегов — пар ключ-значение. Вот пример магазина, который указан на карте как элемент типа Node:
Актуальную выгрузку данных OpenStreetMap можно взять с сайта [GIS-Lab.info](http://gis-lab.info/projects/osm_dump/). Так как нас интересует Москва и ее ближайшее окружение, загрузим файл [RU-MOS.osm.pbf](http://data.gis-lab.info/osm_dump/dump/latest/RU-MOS.osm.pbf) — часть OpenStreetMap из соответствующего региона в бинарном формате [osm.pbf](https://pypi.python.org/pypi/osmread). Для чтения таких файлов из Python имеется простая библиотека osmread.
Прежде чем начать работать, считаем из OSM все элементы типа Node из нужной нам области, которые имеют теги (остальные отсеим и не будем использовать в дальнейшем).
Организаторы соревнования подготовили бейзлайн, который доступен по [ссылке](https://github.com/datasouls/mts-geohack). Весь код, который приведен далее содержится в этом бейзлайне.
**Загрузка объектов из OpenStreetMap**
```
import pickle
import osmread
from tqdm import tqdm_notebook
LAT_MIN, LAT_MAX = 55.309397, 56.13526
LON_MIN, LON_MAX = 36.770379, 38.19270
osm_file = osmread.parse_file('osm/RU-MOS.osm.pbf')
tagged_nodes = [
entry
for entry in tqdm_notebook(osm_file, total=18976998)
if isinstance(entry, osmread.Node)
if len(entry.tags) > 0
if (LAT_MIN < entry.lat < LAT_MAX) and (LON_MIN < entry.lon < LON_MAX)
]
# Сохраним список с выбранными объектами в отдельный файл
with open('osm/tagged_nodes.pickle', 'wb') as fout:
pickle.dump(tagged_nodes, fout, protocol=pickle.HIGHEST_PROTOCOL)
# Файл с сохраненными объектами можно будет быстро загрузить
with open('osm/tagged_nodes.pickle', 'rb') as fin:
tagged_nodes = pickle.load(fin)
```
Работая в Python, геоданные можно быстро визуализировать на интерактивной карте при помощи библиотеки [folium](https://github.com/python-visualization/folium), у которой под капотом [Leaflet.js](http://leafletjs.com) — стандартное решение для отображения OpenStreetMap.
**Пример визуализации при помощи folium**
```
import folium
fmap = folium.Map([55.753722, 37.620657])
# нанесем ж/д станции
for node in tagged_nodes:
if node.tags.get('railway') == 'station':
folium.CircleMarker([node.lat, node.lon], radius=3).add_to(fmap)
# выделим квадраты с наибольшим числом вызовов
calls_thresh = df_zones.calls_daily.quantile(.99)
for _, row in df_zones.query('calls_daily > @calls_thresh').iterrows():
folium.features.RectangleMarker(
bounds=((row.lat_bl, row.lon_bl), (row.lat_tr, row.lon_tr)),
fill_color='red',
).add_to(fmap)
# карту можно сохранить и посмотреть в браузере
fmap.save('map_demo.html')
```
Агрегируем полученный набор точек по квадратам и построим простые признаки:
1. Расстояние от центра квадрата до Кремля
2. Число точек в радиусе R от центра квадрата (для различных значений R)
a. всех точек с тегами
b. ж/д станций
c. магазинов
d. остановок общественного транспорта
3. Максимальное и среднее расстояние от центра квадрата до ближайших точек перечисленных выше видов
Для быстрого поиска точек, находящихся в близости с центром квадрата, будем использовать [структуру данных k-d tree](https://en.wikipedia.org/wiki/K-d_tree), реализованную в пакете SciKit-Learn в классе NearestNeighbors.
**Построение таблицы с признаковым описанием квадратов**
```
import collections
import math
import numpy as np
from sklearn.neighbors import NearestNeighbors
kremlin_lat, kremlin_lon = 55.753722, 37.620657
def dist_calc(lat1, lon1, lat2, lon2):
R = 6373.0
lat1 = math.radians(lat1)
lon1 = math.radians(lon1)
lat2 = math.radians(lat2)
lon2 = math.radians(lon2)
dlon = lon2 - lon1
dlat = lat2 - lat1
a = math.sin(dlat / 2)**2 + math.cos(lat1) * math.cos(lat2) * \
math.sin(dlon / 2)**2
c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
return R * c
df_features = collections.OrderedDict([])
df_features['distance_to_kremlin'] = df_zones.apply(
lambda row: dist_calc(row.lat_c, row.lon_c, kremlin_lat, kremlin_lon), axis=1)
# набор фильтров точек, по которым будет считаться статистика
POINT_FEATURE_FILTERS = [
('tagged', lambda
node: len(node.tags) > 0),
('railway', lambda node: node.tags.get('railway') == 'station'),
('shop', lambda node: 'shop' in node.tags),
('public_transport', lambda node: 'public_transport' in node.tags),
]
# центры квадратов в виде матрицы
X_zone_centers = df_zones[['lat_c', 'lon_c']].as_matrix()
for prefix, point_filter in POINT_FEATURE_FILTERS:
# берем подмножество точек в соответствии с фильтром
coords = np.array([
[node.lat, node.lon]
for node in tagged_nodes
if point_filter(node)
])
# строим структуру данных для быстрого поиска точек
neighbors = NearestNeighbors().fit(coords)
# признак вида "количество точек в радиусе R от центра квадрата"
for radius in [0.001, 0.003, 0.005, 0.007, 0.01]:
dists, inds = neighbors.radius_neighbors(X=X_zone_centers, radius=radius)
df_features['{}_points_in_{}'.format(prefix, radius)] = \
np.array([len(x) for x in inds])
# признак вида "расстояние до ближайших K точек"
for n_neighbors in [3, 5, 10]:
dists, inds = neighbors.kneighbors(X=X_zone_centers, n_neighbors=n_neighbors)
df_features['{}_mean_dist_k_{}'.format(prefix, n_neighbors)] = \
dists.mean(axis=1)
df_features['{}_max_dist_k_{}'.format(prefix, n_neighbors)] = \
dists.max(axis=1)
df_features['{}_std_dist_k_{}'.format(prefix, n_neighbors)] = \
dists.std(axis=1)
# признак вида "расстояние до ближайшей точки"
df_features['{}_min'.format(prefix)] = dists.min(axis=1)
# Создаем таблицу и сохраняем ее в features.csv
df_features = pandas.DataFrame(df_features, index=df_zones.index)
df_features.to_csv('data/features.csv')
df_features.head()
```
В итоге для каждого квадрата из обучающей и тестовой выборки имеем признаковое описание, которое можно использовать для предсказания. Небольшой модификацией предложенного кода можно учесть в признаках объекты других типов. Участники могут добавлять свои признаки, тем самым давая модели больше информации о городской застройке.
**Предсказание числа вызовов**
Опытные участники соревнований по анализу данных знают, что для получения высокого места важно не только смотреть на публичный лидерборд, но и делать собственную валидацию на тренировочной выборке. Сделаем простое разбиение тренировочной части выборки на подвыборки для обучения и валидации в соотношении 70/30.
Возьмем только целевые квадраты и обучим модель случайного леса (RandomForestRegressor) предсказывать среднее число вызовов в день.
**Выделение валидационной подвыборки и обучение RandomForest**
```
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
df_zones_train = df_zones.query('is_test == 0 & is_target == 1')
idx_train, idx_valid = train_test_split(df_zones_train.index, test_size=0.3)
X_train = df_features.loc[idx_train, :]
y_train = df_zones.loc[idx_train, 'calls_daily']
model = RandomForestRegressor(n_estimators=100, n_jobs=4)
model.fit(X_train, y_train)
```
Оценим качество на валидационной подвыборке, для всех дней недели построим одинаковый прогноз. Метрика качества — непараметрический коэффициент корреляции Кендалла tau-b, он реализован в пакете [SciPy](https://www.scipy.org) в виде функции scipy.stats.kendalltau.
Получается Validation score: 0.656881482683
Это неплохо, т.к. значение метрики 0 означает отсутствие корреляции, а 1 — полное монотонное соответствие реальных значений и предсказанных.
**Прогноз и оценка качества на валидации**
```
from scipy.stats import kendalltau
X_valid = df_features.loc[idx_valid, :]
y_valid = df_zones.loc[idx_valid, 'calls_daily']
y_pred = model.predict(X_valid)
target_columns = ['calls_wd{}'.format(d) for d in range(7)]
df_valid_target = df_zones.loc[idx_valid, target_columns]
df_valid_predictions = pandas.DataFrame(collections.OrderedDict([
(column_name, y_pred)
for column_name in target_columns
]), index=idx_valid)
df_comparison = pandas.DataFrame({
'target': df_valid_target.unstack(),
'prediction': df_valid_predictions.unstack(),
})
valid_score = kendalltau(df_comparison['target'], df_comparison['prediction']).correlation
print('Validation score:', valid_score)
```
До вхождения в ряды участников, которые получат приглашение на Data Fest, остается один небольшой шаг: построить таблицу с предсказаниями на всех тестовых квадратах и отправить их в систему.
**Построение предсказаний на тесте**
```
idx_test = df_zones.query('is_test == 1').index
X_test = df_features.loc[idx_test, :]
y_pred = model.predict(X_test)
df_test_predictions = pandas.DataFrame(collections.OrderedDict([
(column_name, y_pred)
for column_name in target_columns
]), index=idx_test)
df_test_predictions.to_csv('data/sample_submission.csv')
df_test_predictions.head()
```
**Зачем анализировать геоданные?**
Основными источниками данных, не только пространственных (географических), но и временных, для любой телеком-компании являются расположенные на всей территории стран обслуживания комплексы аппаратуры для приема и передачи сигнала — Базовые Станции (БС). Пространственный анализ данных труднее технически, но может принести существенную пользу и получить признаки, добавляющие весомый вклад в эффективность моделей машинного обучения.
В компании МТС использование географических данных помогает расширить базу знаний. Они могут использоваться для повышения качества предоставляемого сервиса при анализе жалоб абонентов на качество связи, улучшения зоны покрытия сигнала связи, планирования развития сети и решения других задач, где пространственно временная связь является важным фактором.
Возрастающая, особенно в крупных городах, плотность населения, стремительное развитие объектов инфраструктуры и дорожной сети, космические снимки и векторные карты, количество строений и POI (points of interest) с открытых карт местности, связанных с оказание сервисных услуг – все эти пространственные данные можно получить из внешних источников. Такие данные могут применяться как дополнительный источник информации, а также позволят получить объективную картину вне зависимости от покрытия сети.
Понравилась задача? Тогда мы приглашаем вас принять участие в онлайн-хакатоне по анализу географических данных [Geohack.112](https://datasouls.com/c/mts-geohack/description). Регистрируйтесь и загружайте свои решения на [сайт](https://datasouls.com/c/mts-geohack/) до 24 апреля. Авторы трех лучших результатов получат денежные призы. Отдельные номинации предусмотрены для участников, представивших лучшее публичное решение задачи и лучшую визуализацию журналистики данных. Общий призовой фонд МТС GeoHack — **500 000 рублей**. Мы надеемся увидеть новые интересные подходы к генерации пространственных фичей, визуализации геоданных и использования новых открытых источников информации.
Награждение победителей пройдет 28 апреля на конференции [DataFest](http://datafest.ru). | https://habr.com/ru/post/353334/ | null | ru | null |
# Секционирование: Выстрелил и забыл
О секционировании можно найти много [информации](http://www.postgresql.org/docs/9.2/interactive/ddl-partitioning.html), в частности [здесь](http://habrahabr.ru/post/74984/) можно прочитать о теории, и [дальше](http://habrahabr.ru/post/75906/) автор развивает идею и предоставляет свое решение для быстрого добавления секции. Рекомендую к ознакомлению.
После изучения теории почти ко всем приходит идея автоматизации процесса создания секций. Выше был один из вариантов, второй [комплексный вариант](http://www.zabbix.com/wiki/non-english/ru/partitioning_in_postgresql) я видел у создателей уважаемого, думаю, не только мной Zabbix.
После небольшого адаптирования я решил внедрить его у себя… К сожалению, в нем выяснилось несколько недостатков: при создании новой секции первая запись в эту секцию терялась; при большом количестве секций вставка даже одной записи занимает слишком много времени (вызвано 2 факторами: каждый раз вычислялась таблица, куда следует положить запись; использования множества rules вместо 1 триггера со всеми условиями). Тем не менее ребята проделали отличную работу и я, пользуясь случаем, посылаю им лучи уважения.
В результате представляю на Ваш суд свое решение. Для начала пример как запустить секционирование:
Диапазон дат:
```
select create_partition('partitions.test1.cdate', 'date', 'day,YYYY_MM_DD', now()::text);
select create_partition('partitions.test2.cdate', 'date', 'week,YYYY_IW', now()::text);
select create_partition('partitions.test3.cdate', 'date', 'month,YYYY_MM', now()::text);
```
Данные команды запустят секционирование по дням, неделям и месяцам для таблиц test1, test2, test3
Разберем параметры:
первое поле '*partitions.test1.cdate*' значения, разделенные точкой:
*partitions* — имя схемы, куда будут складываться секции
*test1* — таблица предок в текущей области видимости
*cdate* — поле, по которому таблица будет разделена
второе поле *'date'* задает тип секций
третье поле *'day,YYYY\_MM\_DD'* задает параметры для секционирования
*day* — создавать секции каждый день
*YYYY\_MM\_DD* — суффикс для таблицы
и, наконец, четвертое *now()::text* пример данных для создания секции
Другой пример:
```
select create_partition('partitions.test4.id', 'digits', '10,2', 1::int);
```
Здесь число будет приводится к 10-разрядному путем добавления нулей слева (если нужно) и все цифры левее восьмой будут браться для имени секции:
1000000000 попадет в секцию partitions.test4\_10
100000000 в секцию partitions.test4\_01
10000000 в секцию partitions.test4\_00
10000000000 в секцию partitions.test4\_100
Кратко опишу как это работает:
при запуске select create\_partition('partitions.test1.cdate', 'date', 'day,YYYY\_MM\_DD', now()::text); первым делом вызывается «плагин» partition\_**date**. Цель этой функции — по переданным параметрам вернуть название секции и условие попадания в нее. Дальше в основной функции создается новая таблица, наследуемая от текущей с нужными условиями, копируются все индексы предка.
Затем запросом из системных таблиц вытаскиваются данные о таблицах-потомках и их check condition из этих данных, пересоздается триггер, который распределяет данные по секциям.
Теперь при любой вставке будет срабатывать триггер и определять нужную таблицу-секцию, если такой таблицы нет, вызывается create\_partition с теми же параметрами, которые были при создании секций.
Для первого примера после года наполнения триггер будет выглядеть так:
```
CREATE OR REPLACE FUNCTION trig_partition_test1_cdate() RETURNS TRIGGER AS $BODY2$
declare
child text;
begin
IF ((NEW.cdate >= '2012-09-01 00:00:00-07'::timestamp with time zone) AND (NEW.cdate < '2012-10-01 00:00:00-07'::timestamp with time zone)) THEN INSERT INTO public.test1_2012_09 VALUES (NEW.*);
ELSIF ((NEW.cdate >= '2012-08-01 00:00:00-07'::timestamp with time zone) AND (NEW.cdate < '2012-09-01 00:00:00-07'::timestamp with time zone)) THEN INSERT INTO public.test1_2012_08 VALUES (NEW.*);
ELSIF ((NEW.cdate >= '2012-07-01 00:00:00-07'::timestamp with time zone) AND (NEW.cdate < '2012-08-01 00:00:00-07'::timestamp with time zone)) THEN INSERT INTO public.test1_2012_07 VALUES (NEW.*);
ELSIF ((NEW.cdate >= '2012-06-01 00:00:00-07'::timestamp with time zone) AND (NEW.cdate < '2012-07-01 00:00:00-07'::timestamp with time zone)) THEN INSERT INTO public.test1_2012_06 VALUES (NEW.*);
ELSIF ((NEW.cdate >= '2012-05-01 00:00:00-07'::timestamp with time zone) AND (NEW.cdate < '2012-06-01 00:00:00-07'::timestamp with time zone)) THEN INSERT INTO public.test1_2012_05 VALUES (NEW.*);
ELSIF ((NEW.cdate >= '2012-04-01 00:00:00-07'::timestamp with time zone) AND (NEW.cdate < '2012-05-01 00:00:00-07'::timestamp with time zone)) THEN INSERT INTO public.test1_2012_04 VALUES (NEW.*);
ELSIF ((NEW.cdate >= '2012-03-01 00:00:00-08'::timestamp with time zone) AND (NEW.cdate < '2012-04-01 00:00:00-07'::timestamp with time zone)) THEN INSERT INTO public.test1_2012_03 VALUES (NEW.*);
ELSIF ((NEW.cdate >= '2012-02-01 00:00:00-08'::timestamp with time zone) AND (NEW.cdate < '2012-03-01 00:00:00-08'::timestamp with time zone)) THEN INSERT INTO public.test1_2012_02 VALUES (NEW.*);
ELSIF ((NEW.cdate >= '2012-01-01 00:00:00-08'::timestamp with time zone) AND (NEW.cdate < '2012-02-01 00:00:00-08'::timestamp with time zone)) THEN INSERT INTO public.test1_2012_01 VALUES (NEW.*);
ELSE
EXECUTE 'SELECT create_partition(''public.test1.cdate''::text, ''date''::text, ''month,YYYY_MM''::text , '''||NEW.cdate||'''::text)' INTO child;
EXECUTE 'INSERT INTO '|| child || ' SELECT $1.*' USING NEW;
END IF;
RETURN NULL;
end;
$BODY$ LANGUAGE 'plpgsql';
```
Как видите, получается практически классический пример из документации :)
Как вы уже догадались, это решение несложно расширить, например, секционированием по первым буквам строки или хеша строки. Предлагаю написать данный «плагин» самостоятельно и выложить в комментариях.
Надеюсь кому-то мое решение будет полезно.
**Вспомогательные скрипты найденные на форуме sql.ru**
```
CREATE OR REPLACE FUNCTION to_timestamp(timestamp without time zone) RETURNS timestamp with time zone AS $_$
select $1::timestamp with time zone;
$_$ LANGUAGE sql STABLE STRICT;
CREATE OR REPLACE FUNCTION to_timestamp(timestamp with time zone) RETURNS timestamp with time zone AS $_$
select $1::timestamp with time zone;
$_$ LANGUAGE sql STABLE STRICT;
CREATE OR REPLACE FUNCTION to_numeric(text) RETURNS numeric AS $_$
select regexp_replace($1, '\D+', '', 'g')::numeric;
$_$ LANGUAGE sql STABLE STRICT;
CREATE OR REPLACE FUNCTION copy_constraints(srcoid oid, dstoid oid)
RETURNS integer AS
$BODY$
declare
i int4 := 0;
constrs record;
srctable text;
dsttable text;
begin
srctable = srcoid::regclass;
dsttable = dstoid::regclass;
for constrs in
select conname as name, pg_get_constraintdef(oid) as definition
from pg_constraint where conrelid = srcoid loop
begin
execute 'alter table ' || dsttable
|| ' add constraint '
|| replace(replace(constrs.name, srctable, dsttable),'.','_')
|| ' ' || constrs.definition;
i = i + 1;
exception
when duplicate_table then
end;
end loop;
return i;
exception when undefined_table then
return null;
end;
$BODY$
LANGUAGE 'plpgsql' VOLATILE;
CREATE OR REPLACE FUNCTION copy_constraints(src text, dst text)
RETURNS integer AS
$BODY$
begin
return copy_constraints(src::regclass::oid, dst::regclass::oid);
end;
$BODY$
LANGUAGE 'plpgsql' IMMUTABLE;
CREATE OR REPLACE FUNCTION copy_indexes(srcoid oid, dstoid oid)
RETURNS integer AS
$BODY$
declare
i int4 := 0;
indexes record;
srctable text;
dsttable text;
script text;
begin
srctable = srcoid::regclass;
dsttable = dstoid::regclass;
for indexes in
select c.relname as name, pg_get_indexdef(idx.indexrelid) as definition
from pg_index idx, pg_class c where idx.indrelid = srcoid and c.oid = idx.indexrelid loop
script = replace (indexes.definition, ' INDEX '
|| indexes.name, ' INDEX '
|| replace(replace(indexes.name, srctable, dsttable),'.','_'));
script = replace (script, ' ON ' || srctable, ' ON ' || dsttable);
begin
execute script;
i = i + 1;
exception
when duplicate_table then
end;
end loop;
return i;
exception when undefined_table then
return null;
end;
$BODY$
LANGUAGE 'plpgsql' VOLATILE;
CREATE OR REPLACE FUNCTION copy_indexes(src text, dst text)
RETURNS integer AS
$BODY$
begin
return copy_indexes(src::regclass::oid, dst::regclass::oid);
end;
$BODY$
LANGUAGE 'plpgsql' IMMUTABLE;
CREATE OR REPLACE FUNCTION copy_triggers(srcoid oid, dstoid oid)
RETURNS integer AS
$BODY$
declare
i int4 := 0;
triggers record;
srctable text;
dsttable text;
script text = '';
begin
srctable = srcoid::regclass;
dsttable = dstoid::regclass;
for triggers in
select tgname as name, pg_get_triggerdef(oid) as definition
from pg_trigger where tgrelid = srcoid loop
script =
replace (triggers.definition, ' TRIGGER '
|| triggers.name, ' TRIGGER '
|| replace(replace(triggers.name, srctable, dsttable),'.','_'));
script = replace (script, ' ON ' || srctable, ' ON ' || dsttable);
begin
execute script;
i = i + 1;
exception
when duplicate_table then
end;
end loop;
return i;
exception when undefined_table then
return null;
end;
$BODY$
LANGUAGE 'plpgsql' VOLATILE;
CREATE OR REPLACE FUNCTION copy_triggers(src text, dst text)
RETURNS integer AS
$BODY$
begin
return copy_triggers(src::regclass::oid, dst::regclass::oid);
end;
$BODY$
LANGUAGE 'plpgsql' IMMUTABLE;
```
**Основные скрипты**
```
CREATE OR REPLACE FUNCTION "create_partition" (in tbl varchar, in method varchar, in params varchar, in sample text) RETURNS text AS $BODY$
declare
scheme varchar := split_part(tbl, '.', 1);
parent varchar := split_part(tbl, '.', 2);
field varchar := split_part(tbl, '.', 3);
child varchar;
script text;
trig text;
part text[];
begin
execute 'select partition_'||method||'('''||params||''', '''||field||''', '''||sample||''')' into part;
-- RAISE EXCEPTION 'part %', part;
child = scheme || '.' || parent || '_' || (part[1]::text);
execute 'create table IF NOT EXISTS ' || child || '
(
constraint partition_' || (part[1]) || ' check '
|| (part[2]) || '
)
inherits (' || parent || ')';
perform copy_constraints(parent, child);
perform copy_indexes(parent, child);
-- execute 'GRANT SELECT ON ' || child || ' TO some_other_user';
-- execute 'GRANT ALL ON ' || child || ' TO user';
script = (select string_agg(c, chr(10)||' ELS') from (
select to_numeric(replace(t.table_name, parent||'_','')) as n, 'IF '||replace(left(right(cc.check_clause, -1), -1), c.column_name, 'NEW.'||c.column_name)||' THEN INSERT INTO '||t.table_schema||'.'||t.table_name||' VALUES (NEW.*);' as c
from information_schema.TABLE_CONSTRAINTS t
join information_schema.CONSTRAINT_COLUMN_USAGE c
ON t.constraint_name = c.constraint_name
join information_schema.check_constraints cc
ON t.constraint_name = cc.constraint_name
where constraint_type IN ('CHECK')
and t.table_name like parent||'\_%'
group by t.table_schema, t.table_name, c.column_name, cc.check_clause
order by n desc) t);
trig = 'trig_partition_'||parent||'_'||field;
execute
'CREATE OR REPLACE FUNCTION '||trig||'() RETURNS TRIGGER AS $BODY2$
declare
child text;
begin
'||script||'
ELSE
EXECUTE ''SELECT create_partition('''''||tbl||'''''::text, '''''||method||'''''::text, '''''||params||'''''::text , ''''''||NEW.'||field||'||''''''::text)'' INTO child;
EXECUTE ''INSERT INTO ''|| child || '' SELECT $1.*'' USING NEW;
END IF;
RETURN NULL;
end;
$BODY2$
LANGUAGE ''plpgsql'' VOLATILE;';
execute 'DROP TRIGGER IF EXISTS t_'||trig||' ON "'||parent||'" CASCADE';
execute 'CREATE TRIGGER t_'||trig||' BEFORE INSERT ON "'||parent||'" FOR EACH ROW EXECUTE PROCEDURE '||trig||'();';
return child;
end;
$BODY$ LANGUAGE 'plpgsql';
CREATE OR REPLACE FUNCTION "partition_date" (in params text, in field varchar, in sample timestamp with time zone) RETURNS text[] AS $BODY$
declare
period varchar:= split_part(params, ',', 1);
fmt varchar := split_part(params, ',', 2);
clock timestamp with time zone := to_timestamp(sample);
delta varchar := '1 '||period;
suffix varchar;
check_beg varchar;
check_end varchar;
condition varchar;
begin
-- RAISE EXCEPTION 'period %, fmt %, clock %', period, fmt, clock;
check_beg = date_trunc(period, clock);
check_end = date_trunc(period, clock + delta::interval);
suffix = to_char (clock, fmt);
condition =
'(
' || field || ' >= ' || quote_literal (check_beg) || ' and
' || field || ' < ' || quote_literal (check_end) || '
)';
return ARRAY[suffix, condition];
end;
$BODY$ LANGUAGE 'plpgsql' IMMUTABLE;
CREATE OR REPLACE FUNCTION "partition_digits" (in params text, in field varchar, in sample numeric) RETURNS text[] AS $BODY$
declare
len int := split_part(params, ',', 1)::int;
pref int := split_part(params, ',', 2)::int;
norm text := to_char(sample::numeric, 'FM000000000000000000000');
suffix text := regexp_replace(left(norm, -1*(len-pref)), '0*(?=\d{'||pref::text||'})', '');
check_beg varchar;
check_end varchar;
condition varchar;
begin
check_beg = (trunc(norm::numeric, -1*(len-pref)))::numeric::text;
check_end = (check_beg::numeric+10^(len-pref))::numeric::text;
condition =
'(
' || field || ' >= ' || check_beg || ' and
' || field || ' < ' || check_end || '
)';
return ARRAY[suffix, condition];
end;
$BODY$ LANGUAGE 'plpgsql' IMMUTABLE;
```
**Тесты**Секции по дате
```
DROP TABLE IF EXISTS "public"."test1" CASCADE;
CREATE TABLE "public"."test1" (
"id" serial,
"cdate" timestamp with time zone,
"text" text,
CONSTRAINT "test11_pkey" PRIMARY KEY (id)
) WITH OIDS;
CREATE INDEX test_idx_cdate ON test1 USING btree (cdate);
-- select create_partition('public.test1.cdate', 'date', 'day,YYYY_MM_DD', now()::text);
-- select create_partition('public.test1.cdate', 'date', 'week,YYYY_IW', now()::text);
select create_partition('public.test1.cdate', 'date', 'month,YYYY_MM', now()::text);
-- insert into test1 (cdate, text) SELECT cdate, md5(random()::text) as text FROM generate_series('2012-01-01'::date, now(), '1 day'::interval) cdate;
```
Секции по диапазону чисел:
```
DROP TABLE IF EXISTS "public"."test2" CASCADE;
CREATE TABLE "public"."test2" (
"id" bigserial,
"text" text,
CONSTRAINT "test2_pkey" PRIMARY KEY (id)
) WITH OIDS;
select create_partition('public.test2.id', 'digits', '10,2', 1::int);
insert into test2 values(10000000, 'test2');
-- insert into test2 (id, text) SELECT t.id, md5(random()::text) as text FROM generate_series(0, 100000000000, 1000000000) as t(id) limit 200;
``` | https://habr.com/ru/post/152125/ | null | ru | null |
# Расширяем hook_node_info() для настройки комментариев, отображения и прочих вещей
Думаю, многие сталкиваются с [подобной проблемой](http://drupal.org/node/1169864): создаешь с помощью `hook_node_info()` новый тип контента, но все равно приходится лезть в интерфейс и настраивать в ручную такие параметры, как отображение комментариев, настройки публикации, отображение даты/автора и прочие вещи, которые `hook_node_info()` не охватывает. А каждый раз использовать костыли типа variable\_set — неудобно.
Мое терпение таки-лопнуло, и пара часов была потрачена на благо человечества: результатом стал небольшой модуль [nodetools](https://github.com/antipin/drupal.nodetools).
Все, что он делает, это позволяет в hook\_node\_info указывать дополнительные свойства создаваемого типа контента.
Его использование выглядит следующим образом ([подробно с комментариями](https://github.com/antipin/drupal.nodetools/blob/master/nodetools.api.php)):
> `php<br/
> function hook\_node\_info() {
>
> return array(
>
> 'customtype' => array(
>
> 'name' => t('Custom node type'),
>
> 'base' => 'custom',
>
> ...
>
> // Extra properties
>
> 'node-preview' => 0,
>
> 'node-options' => array('status', 'promote', 'sticky', 'revision'),
>
> 'node-submitted' => 0,
>
> 'comment' => array(
>
> 'status' => 2,
>
> 'default-mode' => 1,
>
> 'anonymous' => 1,
>
> 'default-per-page' => 50,
>
> 'form-location' => 1,
>
> 'preview' => 0,
>
> 'subject-field' => 0,
>
> ),
>
> ),
>
> );
>
> }
>
> \* This source code was highlighted with Source Code Highlighter.`
Уверен, многим пригодится :) | https://habr.com/ru/post/135883/ | null | ru | null |
# By lamers for lamers
#### Я ламер.
Я, честно, не являюсь сверхпрофессионалом ни в одном языке программирования, не понимаю, как работает современное ядро windows, linux, в знании ассемблера не продвинулся дальше знания PDP11 и слегка x86 (да и то что знал — забыл), что такое функциональные языки узнал не очень давно и так и не удосужился изучить теорию, в итоге не очень их понимаю. Более того, я с трудом могу объяснить, как работает процессор, программировал ПЛИСы и PIC-контроллеры только в институте и было это очень давно.
Но почему-то у меня очень часто получается решить проблемы, перед которыми пасуют крутые профессионалы.
Вместе с этим мне хотелось бы поднять вопрос необходимости ШИРОКИХ знаний у любого IT'шника. Да и не только IT'шника.
Отчасти этот пост — протест против засилья мнения, что PHP-программисту не нужен JavaScript (например комментарии [здесь](http://habrahabr.ru/blogs/i_am_advertising/133942/)), аналитику не надо уметь пользоваться Visual Basic'ом в Excel'е, а маркетологу достаточно прочитать Котлера, и после этого ему надо только креативить. Т.е. против узкой специализации. Я видел, как хорошие специалисты делали удивительные вещи при помощи сводных таблиц в Excel, пока все остальные требовали от IT-специалистов срочно внедрить BI и сделать нужные отчеты.
Боюсь, что поднятие этой темы в чистом и первозданном виде уведет всех в очень философские разговоры, которые ни к чему не приведут.
Поэтому, вот пример того, как я решаю свои проблемы, пользуюясь головой и не имея супер-знаний.
#### Проблема.
Как-то раз сотрудник, которому приходилось часто переводить таблицы из Excel в html сказал, что делать это без DreamWeaver очень долго и сложно. И вообще нет бесплатных редакторов, которые позволят работать достаточно быстро.
Я усомнился в этом и решил посмотреть, что можно сделать в Notepad++.
Проблема в том, что Excel генерит кучу лишних атрибутов в тэгах и код надо долго и муторно чистить. Причем, Excel дробит строчки на части, а поиск и замена Notepаd++ проводит замену построчно.
В общем, попробуйте сами сохранить xls файл в html, а затем открыть html в Notepad++.
Т.е. проблема есть. И на первый взгляд — не решаемая. Как я уже говорил, я ламер и не могу написать свой плагин или быстренько поправить код Notepad++.
Но есть Google, который сказал, что есть замечательный плагин Pork2Sausage, который позволяет обработать выделенный текст произвольным консольным приложением.
Я тут же скачал этот плагин, написал приложение на c# и… И понял, что мне он не поможет.
Почему-то русские буквы жутко корежились.
Сдаваться не хотелось, потому я скачал исходник Pork2Sausage и со страхом открыл его. Оказалось все не так страшно. Код был простой и мне пришлось только поправить запутанный кусок, который я толком не понял. И все заработало. Правда только для текстов в UTF-8, но мне этого вполне хватало.
Теперь я могу:
1. чистить тэги одной кнопкой
2. делать новые утилиты для изменения текста. Очень полезно во многих случаях. Могу, например, сделать в notepad++ утилиту, которая будет забирать все тексты из habrahabr по какому-нибудь тэгу. Ну или любую другую глупость
#### Что для этого пришлось сделать.
##### Pork2Sausage
Код:
> `std::string inputA = pAsciiText;
>
> std::wstring inputW(inputA.begin(), inputA.end());
>
> inputW.assign(inputA.begin(), inputA.end());
>
> selectedText += inputW;`
>
>
заменить на:
> `size_t templen = 0;
>
> while (pAsciiText[templen]!=L'\0' && templen <= asciiTextLen) templen++;
>
> templen = (templen-1)/sizeof(wchar_t);
>
> wchar_t *inputW = new wchar_t[templen];
>
> wcsncpy(inputW,pAsciiText,templen);
>
> selectedText += inputW;`
>
>
Ну и добавил в функцию launchProgram:
> `char* filename;
>
> if (progInputStr != TEXT("")) {
>
> filename = new char[progInputStr.length()];
>
> wcstombs(filename,progInputStr.c_str(),progInputStr.length()+1);
>
> remove(filename);
>
> }
>
> if (progOutputStr != TEXT("")) {
>
> filename = new char[progOutputStr.length()];
>
> wcstombs(filename,progOutputStr.c_str(),progOutputStr.length()+1);
>
> std::remove(filename);
>
> }`
>
>
чтоб файлы не плодились.
Наверняка я сделал глупо и не оптимально, но работает.
##### Собственно скрипт очистки
Создал консольное приложение на С# с кодом:
> `string strAll="";
>
> strAll = File.ReadAllText("C:\\tmp\\in_"+args[2]);
>
> Regex reg = new Regex(args[0]);
>
> strAll = strAll.Replace("\r\n", " \r\n");
>
> strAll = reg.Replace(strAll, args[1]);
>
> strAll = strAll.Replace(" \r\n", "\r\n");
>
> File.WriteAllText("C:\\tmp\\out_" + args[2], strAll);`
>
>
Тоже код не мастерский.
##### Конфигурируем
Написал в ini файле Pork2Sausage
> `[excel_convertor]
>
> progPath=C:\regexp_notepad\bin\Release\regexp_notepad.exe
>
> progCmd=regexp_bstd "<([a-z]*) [^>]*>" "<$1>" "$(TIMESTAMP)"
>
> workDir=C:\regexp_notepad\bin\Release\
>
> progInput=C:\tmp\in_$(TIMESTAMP)
>
> progOutput=C:\tmp\out_$(TIMESTAMP)`
>
>
Все. Все работает.
И не надо быть суперпрограммистом, чтоб решить большинство проблем.
Те, кто дочитал до конца наверняка имеют свои LifeHack'и такого вида. Давайте делиться.
#### И повторяю вопрос.
Надо ли программисту иметь широкие знания? Например, не бояться задач на JavaScript, если ты PHP-программист? Уметь, если надо воспользоваться Excel'ем и VisualBasic'ом, не бояться MS SQL, сводных таблиц и прочих кубов, если ты аналитик и т.д.?
Или это все от нечистого и если работодатель не обеспечил всеми материалами (отчетами, данными в нужном виде и т.д.), то можно ничего не делать и ждать, а если требуют делать, то начальство не понимает специфики? | https://habr.com/ru/post/136291/ | null | ru | null |
# Введение в непрерывную поставку (CD) при помощи GitLab
Введение в непрерывную поставку (CD) при помощи GitLab
======================================================
Данный туториал позволит вам быстро прочувствовать как происходит командная работа с использованием GitLab. В целом, начать практиковать DevOps/CD с GitLab проще чем с использованием других продуктов потому что GitLab — это решение "всё в одном".
В процессе этого туториала мы
* настроим базовое управления проектом на GitLab.com;
* создадим конвейер непрерывной поставки
* проведём несколько циклов работы с GitLab Flow
* изучим метрики CI/CD в GitLab
Желательны но необязательны базовые знания
* Git;
* Node.js;
* React;
* Docker;
Время от времени я буду просить вас что-то сделать. Такие моменты помечены значком "**!**". Пожалуйста выполняйте действия по мере чтения текста чтобы получить от данного туториала наибольшую пользу.
> В оригинале места где требовалось что-то сделать были помечены эмодзи "молоток и гаечный ключ". Так как редактор habr'а вырезает эмодзи, я заменил эти эмодзи на "**!**".
>
>
>
> Трудно переводить на русский вещи, которые даже русскоязычные программисты между собой называют по-английски. Я постарался литературно переводить термины для которых есть общепринятые переводы и не переводить остальные. Например, мы будем использовать словечки вроде "чекбокс" и "коммитить", а названия разных штук в GitLab останутся на английском, как есть.
Введение и знакомство с проектом
--------------------------------
В качестве "подопытного кролика" мы будем использовать чуть модифицированный шаблонный проект, созданный утилитой **create-react-app**.
> Почему React? Во-первых, это самая распространённая UI-библиотека на JavaScript, и многие читатели знакомы с ней. Во-вторых **create-react-app** даёт нам осмысленные стадии компиляции и тестирования которые уже реализованы за нас.
**!** Теперь давайте клонируем репозиторий с кодом с которым мы будем работать.
```
git clone https://github.com/ntaranov/gitlab-cd-react
```
**!** Перейдите в каталог локального репозитория
```
cd gitlab-cd-react
```
Должна отобразиться стандартная стартовая страница **create-react-app**.
> Вы можете вместо этого этапа просто создать новое приложение при помощи create-react-app, но версия в репозитории содержит некоторые правки, и версии пакетов в коде в репозитории я тестировал.
**!** Установите **npm** пакеты локально, выполнив
```
npm install
```
> Используйте `npm ci` если при выполнении `npm install` произойдёт ошибка
**!** Попробуйте "собрать" проект
```
npm run build
```
Обратите внимание, что в папке `./build` появились соответствующие файлы, включая минифицированный JavaScript и CSS.
**!** Затем запустите тесты
```
npm run test -- --coverage --watchAll=false --forceExit
```
**!** Осталось осуществить "развёртывание", но чтобы не засорять туториал инструкциями по установке веб-сервера, давайте просто запустим отладочный веб-сервер чтобы увидеть как выглядит наше веб приложение выглядит в браузере.
```
npm start
```
Если подумать, то осталось заменить последнюю инструкцию на копирование статических файлов из папки `./build` на веб-сервер — и развёртывание можно считать завершённым. В принципе, это вполне хватит для самостоятельной работы, однако для работы в команде в режиме непрерывной поставки может также захотеться иметь как минимум следующее:
* централизованный репозиторий с
+ управлением полномочиями членов команды;
+ code review;
* багтрекер чтобы
+ планировать работу и
+ отслеживать прогресс;
* среду сборки с
+ автоматическим запуском конвейера непрерывной поставки в нужные моменты;
+ визуализацией статуса сборки;
+ хранением артефактов;
+ автоматическим оповещением о ключевых событиях;
+ автоматическим развёртыванием в разные среды;
* сбор метрик непрерывной доставки.
Всё это, а также многое другое, поддерживается GitLab. [Платная версия](https://about.gitlab.com/pricing/) предлагает больше возможностей, но для наших целей нам хватит и бесплатной версии доступной на [GitLab.com](https://gitlab.com).
> GitLab выделяется на общем фоне отсутствием ограничений на использование собственных job runners, однако некоторые довольно базовые "управленческие" и "корпоративные" фичи GitLab вроде обязательного утверждения merge request'ов входят в платные версии. Проектам с открытым кодом все фичи GitLab доступны бесплатно.
️ Базовая настройка управления проектом на GitLab.com
-----------------------------------------------------
В этой части мы создадим сам проект в GitLab и задачи над которыми будем работать в дальнейшем, а также настроим Kanban-доску для визуализации состояния проекта.
### Создание проекта в GitLab
Мы будем использовать GitLab.com в качестве инсталляции GitLab чтобы избежать хлопот по установке и настройке локальной версии.
**!** Если у вас ещё нет учётной записи на GitLab.com, зайдите на `https://gitlab.com` и заведите её.
GitLab позволяет нам создать проект просто выполнив `push` в удалённый репозиторий.
**!** Воспользуемся для этого следующей командой:
```
git push https://gitlab.com//gitlab-cd-react
```
тут — ваше имя пользователя на GitLab.com.
Эта команда создаст приватный проект с именем `gitlab-cd-react` внутри вашей учётной записи на GitLab.com.
**!** Пожалуйста перейдите по адресу `https://gitlab.com//gitlab-cd-react`.
Далее мы настроим канбан-доску, а заодно создадим несколько задач чтобы было вокруг чего строить дальнейшую работу и о чём собирать статистику.
### ️ Создание задач и настройка доски
Давайте начнём с создания задачи.
**!** Кликните **Issues** в левом меню, затем нажмите одну из кнопок **New Issue** в основной области. Откроется форма создания задачи. Укажите в качестве заголовка "Создать задания для туториала".
В описании укажите следующий текст
```
Создайте задачи с заголовками, перечисленными в списке ниже.
- [ ] Создать метки
- [ ] Настроить доску
- [ ] Создать конвейер непрерывной поставки
- [ ] Провести несколько итераций GitLab Flow
- [ ] Изучить метрики
```
Да, именно эти вещи мы и будем делать в дальнейшем. Оставьте остальные значения по умолчанию. Нажмите кнопку **Submit issue**.
Обратите внимание, что список с пробелами в квадратных скобках вначале элементов был распознан как чеклист, а отдельные его элементы как задачи. GitLab, как и многие другие платформы, использует **Markdown** в качестве языка разметки.
**!** Назначьте задачу `Создать задания для туториала` на себя. Для этого нажмите ссылку **Edit** в панели с надписью **0 Assignees** справа на странице редактирования задачи.
Поздравляю, теперь вы — исполнитель. На самом деле на этом этапе задача может быть назначена любому члену команды но т.к. по сути ничего не изменится, мы не будем плодить пользователей.
**!** Давайте теперь на самом деле создадим все задачи, перечисленные в описании нашей первой задачи. Укажите только заголовки, остальные поля оставьте по умолчанию. Вы можете "ставить галочки" в описании задачи `Создать задания для туториала` как по мере создания задач, так и все сразу когда закончите.
Существуют разные способы создавать задачи, при создании задач по списку найдите и используйте хотя бы 3 разных способа. В итоге у вас должно получиться 6 задач.
**!** Закройте задачу `Создать задания для туториала`. Для этого можете в **Issues** -> **List** или **Issues** -> **Board** кликнуть на заголовок задачи и внутри формы редактирования задачи нажать на кнопку **Close issue**.
### Наш процесс работы
Под процессом работы(workflow) обычно подразумевается порядок этапов, которые задача проходит для того чтобы считаться выполненной. В Continuuos Delivery, Kanban и DevOps задача движется через некую последовательности состояний либо вперёд, либо может быть возвращена на один из предыдущих этапов.
> Это подразумевает линеаризованные value streams. Про value streams можно [почитать тут](https://en.wikipedia.org/wiki/Value-stream_mapping#Purpose_of_value-stream_mapping). Превращение порой затейливой диаграммы переходов в последовательность состояний является иногда очень сложной управленческой задачей, решение которой выходит за границы этой статьи.
Мы будем использовать простую последовательность состояний
* Open
* Dev
* Dev: done
* QA
* Closed
Вначале задача оказывается в состоянии **Open**. Затем она затягивается(pull) в работу разработчикам в стадию **Dev**. После того, как работа завершена, происходит передача задачи в стадию **Dev: done**.
> Зачем нам нужна эта дополнительная стадия? Дело в том что в [Lean](https://en.wikipedia.org/wiki/Lean_manufacturing), на котором основаны все методологии типа CD, Kanban и DevOps, следующий этап(work center) затягивает задачи когда он готов в отличие от методологий где задачи передаются в следующий этап предыдущим. Это позволяет отслеживать задачи которые находятся в стадии ожидания, а накопление задач в стадии ожидания позволяет нам понять, где в нашем "конвейере" "бутылочное горлышко".
Итак, затем задача затягивается в этап **QA** где работают специалисты по качеству и автотесты, а "выпускники" **QA** считаются настолько хорошими что развёртываются непосредственно на продуктив.
> "Ну так же не бывает, это же чих-пых — и в продакшн, должны же быть другие среды типа Staging в процессе!" — скажете вы. Я совершенно согласен, но тут мы используем максимально простой в реализации и для понимания конвейер чтобы меньше отвлекаться от GitLab и не закопаться где-нибудь в дебрях Kubernetes.
### ️ Настройка меток
Для организации задач GitLab использует метки(labels). Они как теги и позволяют искать, фильтровать и отображать задачи в разных местах в зависимости от наличия той или иной метки. Давайте заведём сами метки
**!** Откройте задачу `Создать метки` и назначьте его на себя. Выберите **Issues** -> **Labels** в левом меню, затем нажмите **New label** в правой части основной области. Заведите таким образом следующие 3 метки, выберите разные цвета на свой вкус.
* Dev
* Dev: done
* QA
Названия меток тут полностью произвольные и никакого особого смысла с точки зрения GitLab в них нет.
**!** Когда закончите, назначьте задачу `Создать метки` статус **Closed**.
Теперь всё готово для настройки Kanban-доски.
### Настройка доски
В GitLab есть [Kanban-доски](https://docs.gitlab.com/ee/user/project/issue_board.html). Они позволяют отображать разные задачи в соответствии с их метками. Несмотря на название они могут быть использованы не только для реализации Kanban, но и Scrum а также других методологий. У нас же уже создана задача для этого.
**!** Назначьте эту задачу на себя.
**!** Выберите **Issues** -> **Boards** в левом меню. Вы увидите доску по умолчанию. В ней уже будут колонки-списки **Open** и **Closed**. Нажмите **Add list** в правой верхней части основной области. Создайте по одному списку для каждой из созданных ранее меток
* Dev
* Dev: done
* QA
Если вы создали их в другом порядке, вы можете изменить порядок, перетаскивая списки "за заголовки".
**!** На странице **Issues** -> **Boards** перетащите задачу `Настроить доску` мышкой из столбца **Open** в столбец **Dev**. Выделите задачу кликнув на часть карточки, не занятую текстом.
Таким образом мы указываем что начали работать над этой задаче. Обратите внимание что у задачи появилась новая метка **Dev**.
**!** Так как всю работу мы уже сделали, переведите задачу в столбец **Dev: done**.
Мы приближаемся к стадии **QA**. Постарайтесь внутренне ощутить себя тестировщиком, подумайте какие разработчики неблагонадёжные люди, и, опционально, разберите при помощи отвёртки небольшой бытовой прибор.
**!** Затем переведите задачу в стадию **QA**. Тут можете несколько раз поперетаскивать задачу из столбца в столбец туда-сюда. Кстати, такие приключения порой и происходят с задачами на данном этапе. В процессе у задачи будет появляться метка нового столбца и исчезать метка предыдущего столбца. В конце концов оставьте задачу в столбце **Closed** и обратите внимание что в результате этого действия она была закрыта.
Есть ещё один полезный интерфейс — [To-Do List](https://gitlab.com/dashboard/todos)(в меню рядом с меню логина есть подменю). Это [список действий](https://docs.gitlab.com/ee/user/todos.html), которые по тем или иным причинам ожидается от вас. Мы не будем останавливаться на нём подробно, но я рекомендую заглядывать в него в процессе туториала время от времени чтобы составить представление о том как эта штука работает.
Конвейер непрерывной поставки
-----------------------------
В этой секции мы реализуем непрерывную поставку(Continuous Delivery) средствами GitLab.
### ️ Построение конвейера непрерывной поставки в GitLab
Для того чтобы на самом деле выполнять код задач конвейеров, **GitLab.com** использует общие агенты (shared runners) которые реализуют [docker executors](https://docs.gitlab.com/runner/executors/). Если вы зарегистрируете свои собственные агенты, вам будет доступна куда большая гибкость в [выборе сред сборки](https://docs.gitlab.com/runner/executors/).
Давайте теперь сконструируем наш конвейер.
**!** Назначьте issue `Создать конвейер непрерывной поставки` и переведите его в статус **Dev**.
**!** Создадим конвейер непрерывной поставки(CI/CD pipeline). Для этого требуется создать файл `.gitlab-ci.yaml`.
На момент написания этой статьи это можно было сделать так.
1. Перейдите в проект **gitlab-cd-react**
2. Либо на странице **Project overview / Details** либо на странице **Repository** вы увидите файлы в вашем репозитории.
3. Выберите опцию **New file** как показано на скриншоте. Вас перенаправят на страницу создания файла.
4. В окне **File name** введите имя файла `.gitlab-ci.yml`, поле **Template** правее заполнится автоматически, появится ещё одно поле **Apply a template**. Ознакомьтесь с доступными опциями, попробуйте повыбирать разные варианты. В конце концов выберите `Bash` — это просто шаблон с командами **bash**, мы будем использовать его в качестве отправной точки.
Давайте разберём полученный файл. Официальная документ по формату файла `.gitlab-ci.yml` находится [тут](https://docs.gitlab.com/ee/ci/yaml/gitlab_ci_yaml.html).
> Формат, который использует GitLab для определения конвейеров сборки — один из самых простых и интуитивно понятных в отрасли.
```
image: busybox:latest
before_script:
- echo "Before script section"
- echo "For example you might run an update here or install a build dependency"
- echo "Or perhaps you might print out some debugging details"
after_script:
- echo "After script section"
- echo "For example you might do some cleanup here"
build1:
stage: build
script:
- echo "Do your build here"
test1:
stage: test
script:
- echo "Do a test here"
- echo "For example run a test suite"
test2:
stage: test
script:
- echo "Do another parallel test here"
- echo "For example run a lint test"
deploy1:
stage: deploy
script:
- echo "Do your deploy here"
```
Чтобы получить нужный нам конвейер чуть модифицируем этот файл.
```
image: busybox:latest
```
`image` задаёт какой образ docker будет использован для выполнения jobs сборки. По умолчанию GitLab использует Docker Hub, но это можно настроить. Нам понадобится образ с предустановленным **Node.js**.
**!** Укажите
```
image: node:14-alpine
```
`before_script` и `after_script` выполняются перед и после каждой задачи соответственно. В процессе выполнения задач, мы будем использовать модули Node.js.
**!** Организуем кэширование модулей для того чтобы не скачивать модули каждый раз из интернета.
```
cache:
key: ${CI_COMMIT_REF_SLUG}
paths:
- .npm/
before_script:
- npm ci --cache .npm --prefer-offline
```
* Мы вначале указываем где задачи будут искать кэш, а именно — внутри текущей папки в подпапке `.npm`.
В качестве ключа кэша используем `${CI_COMMIT_REF_SLUG}`, это означает что мы держим отдельный кэш для каждой ветви в Git.
* В `before_script` мы устанавливаем пакеты в соответствии с `package-lock.json`, указывая в качестве пути для кэша подпапку `.npm`.
Таким образом, в дальше в коде `.gitlab-ci.yml` мы можем исходить что пакеты уже установлены.
`after_script` нам в этом туториале не понадобится.
Перейдём к секции `build1`, изначально там должно быть что-то вроде этого:
```
build1:
stage: build
script:
- echo "Do your build here"
```
Обратим внимание на кусок `stage: build`. `stage` определяет этап конвейера, этапы выполняются один за другим. Один этап может содержать одну или более задач, которые могут выполняться параллельно.
**!** Изменим команды чтобы действительно осуществлять сборку:
```
build1:
stage: build
script:
- npm run build
artifacts:
expire_in: 1 week
paths:
- 'build/'
```
* `npm ci` устанавливает необходимые модули в соответствии с файлом `package-lock.json` без проверки существуют ли они уже в папке `node_modules`.
* `npm run build` запускает саму сборку минифицированного React-приложения.
* `artifacts` указывает какие файлы должны быть сохранены для использования в будущем. **Webpack** с настройками **create-react-app** по умолчанию копирует файлы в папку `build`. `expires_in` мы используем для того чтобы не тратить место на уже не нужные сборки.
Обратим теперь внимание на кусок кода для этапа `stage: test`
```
test1:
stage: test
script:
- echo "Do a test here"
- echo "For example run a test suite"
test2:
stage: test
script:
- echo "Do another parallel test here"
- echo "For example run a lint test"
```
**!** Нам не нужна задача `test2`, а задачу `test1` изменим следующим образом:
```
test1:
stage: test
script:
- "CI=true npm test"
dependencies:
- build1
```
* `npm test` тут запускает модульные тесты, определённые в нашем проекте.
* `dependencies` указывает что данная задача `test1` зависит от результатов задачи `build1` чтобы артефакты этой задачи были доступны в текущей.
Перейдём к части связанной напрямую с развёртыванием.
```
deploy1:
stage: deploy
script:
- echo "Do your deploy here"
```
Эта часть обычно завязана на специфику среды в которую осуществляется развёртывание и потому технически сложна. GitLab поддерживает развёртывание в Kubernetes с минимальными усилиями по настройке. Альтернативой является реализация логики развёртывания в другую среду своими силами. Оставим технические детали этого процесса для будущих статей. Фокус данной статьи на объяснении основ работы с GitLab, поэтому мы прибегнем к хитрости, а точнее используем то обстоятельство что наше приложение на React технически является статическим вебсайтом и развернём его на GitLab Pages, которые доступны любому у кого есть учётная запись на GitLab.com.
**!** Заменим job `deploy1` на этот код.
```
pages:
stage: deploy
script:
- mv public _public
- mv build public
only:
- master
artifacts:
paths:
- public
dependencies:
- build1
```
Мы переименовали `deploy1` в `pages` потому что GitLab именно по названию задачи понимает что требуется развернуть файлы доступные этой задаче в GitLab Pages.
Далее делаем 2 вещи.
* `mv public _public` сохраняет папку `public` которая есть в приложении, сгенерированном из шаблона **create-react-app**. Мы делаем это потому что GitLab будет возвращать в ответ на запросы к Pages именно содержимое папки `public`.
* `mv build public` — тут мы как раз помещаем результат сборки туда где веб-сервер GitLab Pages будет искать его.
Завершим на этом работу над нашим конвейером.
**!** Закоммитьте отредактированный файл `.gitlab-ci.yml`, укажите "Add CI/CD pipeline" в качестве **Commit message**, оставьте в качестве ветви `master`.
**!** Переведите задачу `Создать конвейер непрерывной поставки` в стадию **Dev: done**.
Проведём несколько циклов работы с GitLab Flow
----------------------------------------------
Git — очень гибкая система контроля версий кода и использовать его можно очень по-разному. Если каждый член команды использует Git по-своему, возникает путаница когда трудно понять логику действий других людей из истории изменений, и никто не понимает что ожидать от других. Об измерении производительности в такой ситуации и говорить не приходится. Для того чтобы такая путаница не возникала участники команды обычно договариваются о единых правила работы с Git, такая договорённость и называется Git workflow.
Чтобы изучить реализацию GitLab Flow в GitLab мы сделаем эти вещи:
* обсудим что такое процесс работы с Git(Git workflow) вообще;
* посмотрим, как в GitLab устроены права доступа и защищённые ветви;
* разберёмся как работают merge request`ы;
* проведём несколько итераций GitLab Flow.
### Процесс работы с Git
Если коротко, то [GitLab Flow](https://docs.gitlab.com/ee/topics/gitlab_flow.html) состоит в том что
* при каждой необходимости что-то изменить в коде создаётся ветвь от главной (в Git по умолчанию `master`);
* затем открывается merge request (в других системах называется pull request) где происходит обсуждение вносимых изменений;
* для каждой из сред (тестовой, продуктивной и т.д.) при этом существует отдельная ветвь;
* одна из "ветвей сред", откуда происходит безусловное развёртывание может совпадать с главной;
* развёртывание происходит путём слияния в ветвь соответствующей среды;
* cлияния происходят из feature branch в главную ветвь или из "менее продуктивной" ветви среды в "более продуктивную".
> На самом деле для реализации CD нам годится любой процесс работы с Git который поддерживает trunk based development, и мы могли бы реализовать любой такой процесс при помощи GitLab. Однако по той причине, что GitLab рекомендует использовать GitLab Flow и для того чтобы не усложнять наш сценарий, мы его и используем.
### Уровни доступа в GitLab
Существует разные [уровни доступа](https://docs.gitlab.com/ee/user/permissions.html), в порядке понижения полномочий.
* **Instance administrator** — доступен только для отдельных инсталляций, может всё.
* **Owner** — владелец группы проектов, может всё кроме чисто технических штук типа включения-отключения фич и интеграции с другими сервисами.
* **Maintainer** — может всё кроме некоторых действий в отношении всего проекта типа изменения его названия или степени видимости, а также деструктивных действий типа удаления задач.
* **Developer** — может то же что и **Maintainer** кроме некоторых администраторских и деструктивных функций внутри проекта типа настройки защищенности ветвей и редактирования комментариев.
* **Reporter** — может редактировать задачи, но не может вносить изменения в репозиторий.
* **Guest** — доступ только на чтение issue кроме конфиденциальных, может создавать новые задачи.
Данные о полномочиях здесь приведены для полноты, активно использовать в рамках туториала мы их не будем.
### Merge requests
[Merge requests](https://docs.gitlab.com/ee/user/project/merge_requests/getting_started.html) — основной способ внесения изменений в код при использовании GitLab. Изменения вносятся в код, затем автором изменений создаётся merge request, который затем обсуждается, в котором происходит code review. Merge request в результате принимается, отправляется на доработку или отклоняется.
**!** Зайдите в задачу `Провести несколько итераций GitLab Flow`, назначьте его на себя и переведите в колонку **Dev**.
**!** Переведите задачу `Создать конвейер непрерывной поставки` в стадию **QA**.
> Да, вот так мы будем тестировать наш конвейер, но вы должны тестировать на реальных проектах более ответственно. Не делайте как я делаю, делайте как я говорю.
Наше приложение бесполезно. В этом нет ничего необычного, ведь в интернете много бесполезных приложений. Чтобы выйти на новый уровень, давайте сделаем наше приложение токсичным. Существуют 2 фичи, которые являются проверенным способом достичь этого.
**!** Откройте файл `src/App.js` на редактирование (**Repository** -> **Files**, **Edit**) и добавьте эту строчку прямо вверху файла.
```
import {useEffect} from 'react';
```
В качестве **Commit message** укажите, например, "Add React imports". В качестве **Target branch** оставьте `master` и нажмите **Commit changes**.
Упс, мы только что закоммитили изменения сразу в `master`. Некоторые workflow позволяют такое, но мы будем работать в рамках GitLab Flow. Избежать подобных казусов в дальнейшем нам поможет фича GitLab под названием **защищённые ветви**(protected branches). Её смысл не в разграничении доступа, а в том, чтобы помочь членам команды работать в рамках договорённостей и избежать случайного изменения и удаления данных в репозитории.
**!** Нажмите в левом меню **Settings** -> **Repository**. В открывшейся странице найдите раздел **Protected Branches**.
Вы увидите что по умолчанию защищена только ветка `master`, но вы можете добавить и другие. И по умолчанию
* **force push** запрещён всем
* **push** разрешён Maintainers
* **merge** разрешён Maintainers
**!** Измените **Allowed to push** на **No one**.
**!** Отлично, давайте вернёмся к редактированию файла `src/App.js`. После строчки
```
function App() {
```
перед строчкой
```
return (
```
добавьте
```
useEffect(() => {
alert('Consent to cookies and everything!');
}, []);
```
Соответствующий участок кода должен теперь выглядеть примерно так
```
// ...other code
function App() {
useEffect(() => {
alert('Consent to cookies and everything!');
}, []);
return (
// ...other code
```
Укажите "Add the annoying popup" в качестве commit message.
Вы увидите что вам предлагается добавить коммит в некую ветвь и в уже автоматически сгенерировано некоторое имя ветви. Мы в будущем заменим это имя на более осмысленное и соответствующее нашему процессу работы с Git, но пока давайте проведём небольшой эксперимент.
**!** Замените предлагаемое имя на `master` и нажмите **Commit changes**.
Вы увидите сообщение об ошибке `You are not allowed to push into this branch`. Хорошо! Защита ветвей работает. Давайте теперь инициируем процедуру внесения изменений в код так как это предполагается делать.
**!** Замените теперь имя ветви с `master` на `feature-cookies-consent`. Оставьте чекбокс **Start a new merge request with these changes** установленным. Будет создана ветвь с указанным названием и изменения будут закоммичены в эту ветвь. Вы окажетесь на странице создания merge request'а. Оставьте
* заголовок merge request'а по умолчанию.
* **Assignee** и **Reviewer** `Unassigned`.
* всё остальное также по умолчанию.
Нажмите **Submit merge request**
Кстати
* **Assignee** — ответственный за работу над merge request'ом и его слияние в целевую ветвь,
* **Reviewer** же изучает предложенные изменения и может согласовать их если они кажутся правильными.
После создания merge request'а, ы окажетесь его на странице. Давайте изучим эту страницу. В основной области мы видим следующее.
* Какую ветвь мы сливаем с какой (`feature-cookies-consent` в `master`).
* Статус pipeline для ветви `feature-cookies-consent`.
* Возможность согласовать merge request от имени текущего пользователя.
* Кнопка **Merge** осуществляет принятие merge request'а и непосредственно слияние ветвей, которое приводит к внесению изменений в `master`.
* Область где можно посмотреть коммиты, которые будут слиты, там же можно изменить сообщение merge commit'а.
* Возможности принять участие в обсуждении:
+ выразить своё отношение и оставить смайлик;
+ область добавления комментария.
* Кнопку **Close merge request**, которая позволяет закрыть merge request без принятия изменений в код `master`.
> Для бесплатных подписок есть только возможность "совещательного" согласования merge request'а, в платных версиях есть возможность сделать согласование необходимым.
Если вы переключитесь на вкладку **Changes**, вы можете посмотреть, какие изменения в код планируется внести. Здесь же вы можете создать комментарий, который будет ссылаться на строку кода.
Кстати, merge requests также поддерживают метки, которые вы можете использовать чтобы было проще находить нужные.
К этому моменту работа конвейера уже должна завершиться и… тесты завершены неуспешно. В нашем конкретном случае это потому что мы использовали `window.alert` который является чисто браузерным объектом и наши выполняемые в среде Node.js юнит-тесты не имеют к нему доступа.
В случае непрерывной поставки требуется очень хороший набор автоматических тестов потому что именно на них переложена почти вся, а в случае непрерывного развёртывания(Continuous Deployment) — вся, ответственность за контроль качества. Поддержание такого набора тестов в актуальном состоянии — главная технический вызов в реализации таких методологий.
**!** Исправим `src/App.js`, добавив проверку на то что код работает в браузере. Давайте поместим код, использующий `window.alert` внутрь блока кода, проверяющего что мы в браузере. Убедитесь что вы редактируете файл в ветке `feature-cookies-consent`.
Должно получиться примерно так
```
// ...other code
function App() {
useEffect(() => {
if (typeof process === 'undefined' || process.release === undefined) {
alert('Consent to cookies and everything!');
}
}, []);
return (
// ...remaining code
```
Добавьте "Ensure running in a browser" в качестве commit message. В качестве **Target Branch** должна быть установлена `feature-cookies-consent`.
**!** Давайте вернёмся в merge request `Add the annoying popup` и нажмём кнопку **Merge** и примем изменения в код. Оставьте чекбокс **Delete source branch** установленным.
При использовании GitLab Flow feature branches традиционно удаляют. Это позволяет избежать замусоривания системы уже неактуальными ветвями и создавать ветвь с тем же именем в случае отправки задачи на доработку.
**!** Откройте **Repository** -> **Graph** и обратите внимание на то что `feature-cookies-consent` теперь слита с `master`.
Затем откройте файл `src/App.js` в ветке `master` и заметьте что код уже содержит правки.
**!** Зайдите в задачу `Провести несколько итераций GitLab Flow` и в основной области нажмите стрелочку вниз рядом с кнопкой **Create merge request**. Укажите имя ветки, которую вы хотите создать чтобы базировать на ней новый merge request. `feature-notifications-consent` вполне подойдёт. Оставьте в качестве source branch `master`.
При создании merge request'а таким образом задача будет закрыта автоматически как только мы сольём код в основную ветвь.
Обратите внимание что автоматически сгенерированное название нашего merge request'а начинается с `Draft:`. Это означает что [merge request помечен как черновик](https://docs.gitlab.com/ee/user/project/merge_requests/drafts.html). Это полезно для авторов чтобы явно обозначить что работа пока не завершена и избежать слияния изменений as is в результате недопонимания. Этого же можно добиться и при помощи кнопки **Mark as draft** в верхней правой части основной области.
Добавим функцию оповещений в наш вебсайт чтобы он выглядел современно.
**!** Давайте для разнообразия внесём изменения в код чуть иначе. На странице merge request'а нажмите кнопку **Open in Web IDE**. Откроется чуть более удобный для работы с кодом интерфейс. Уже из него откройте файл `src/App.js`. Добавьте код
```
Notification.requestPermission().then(function(result) {
alert(`You ${result} notifications`);
});
```
после ранее добавленной строчки
```
alert('Consent to cookies and everything!');
```
**!** Нажмите кнопку **Commit** в левой нижней части. Вы увидите интерфейс коммита, укажите в качестве commit message "Add the notifications users want". Оставьте всё остальное по умолчанию и нажмите кнопку **Commit**.
**!** Перейдите в merge request, например, используя подменю в верхней правой части экрана рядом с меню логина.Нажмите кнопку **Mark as ready** в верхней правой части формы merge request'а. Нажмите кнопку **Merge** или **Merge when pipeline succeeds** в зависимости от того завершился ли уже конвейер.
**!** Откройте наш тестовый вебсайт и убедитесь что новые "фичи" работают, и наша страница ощущается как большинство современных сайтов в интернете.
**!** Если с сайтом всё хорошо, перетащите задачу `Создать конвейер непрерывной поставки` в стадию **Closed** на доске.
Итак, мы провели несколько полных циклов работы и теперь можем изучить метрики, которые GitLab собрал в процессе работы.
Метрики CI/CD в GitLab
----------------------
В процессе командной работы полезно собирать статистику чтобы понимать повышается ли продуктивность или падает. Способы оценки производительности могут быть совсем разными в зависимости от характера работы и типа проекта или продукта.
> Например, веб-студия может иметь "типовые" задачи типа отрисовки макета в рамках стандартного пакета услуг, предлагаемого клиенту. Agile стартап же может находиться в стадии когда концепция продукта меняется вместе с растущим пониманием потребностей клиента и рынка, и задачи могут быть трудно предсказуемы и часто уникальны. Вместе с тем, можно выделить чисто технические показатели производительности вроде одного из основных для DevOps времени вывода новой фичи на рынок (time to market, TTM) или просто длительности той или иной стадии. Отслеживать динамику таких показателей может быть очень полезно: за достаточно длительный период времени это позволяет понять как изменяется производительность.
Хорошей новостью является то что GitLab имеет функционал сбора этой статистики. Давайте с этим функционалом познакомимся.
**!** Кликните на **Analytics**. По умолчанию откроется раздел [**Value stream**](https://docs.gitlab.com/ee/user/analytics/value_stream_analytics.html). В Lean вообще и в DevOps в частности считается что задачи несут в конечном итоге некоторую пользу для конечного заказчика. И движение таких полезных задач, от стадии формулирования через все этапы работы до того момента когда результаты становятся доступны заказчику называется value stream.
Основные средние величины по этапам:
* **Issue** — время которое уходит на то чтобы задачу "взять в работу" т.е. присвоить метку или добавить в Milestone.
* **Plan** — время от последнего действия в предыдущем этапе до появления первого коммита в ветке, хоты бы один из коммитов которой связан с той же задачей. То есть "время, которое уходит чтобы начать коммитить".
* **Code** — время существования ветки, связанной с той или иной задачей, которое уходит до появления merge request'a.
* **Test** — время от начала до конца всех конвейеров данного проекта.
* **Review** — время от создания merge request'а до его слияния или закрытия.
* **Staging** — время от принятия merge request до развёртывания в продуктивную среду.
Если вы сложите длительность **Issue**, **Plan**, **Code**, **Review** и **Staging**, вы и получите примерно то самое заветное время для вывода на рынок (TTM).
Наверху страницы в также увидите некие агрегатные показатели по проекту за выбранный период времени.
**Analytics** -> **Repository** показывает разные графики связанные с языками коммитов, показателями code coverage (если настроено), распределением коммитов во времени (месяц, дни недели, часы).
**Analytics** -> **CI/CD** показывает сводные данные по выполенным pipelines, в том числе график показывающий динамику изменения "успешности" выполнения pipelines.
Поздравляю!
-----------
Вы осуществили имплементацию непрерывной поставки(CD) при помощи GitLab начиная с задач с канбан-доской и завершая метриками.
Ссылки
------
1. [GitLab product handbook](https://about.gitlab.com/handbook/product/gitlab-the-product)
2. [The DevOps Handbook](https://www.amazon.ca/DevOps-Handbook-World-Class-Reliability-Organizations/dp/1942788002)
3. [Pro Git Book](https://git-scm.com/book/en/v2) | https://habr.com/ru/post/549862/ | null | ru | null |
# Именованные кортежи из выборок
В Django для ускорения запросов, возвращающих большое количество данных, существуют методы `QuerySet`-а `values()` и `values_list()`. Первый вместо моделей возвращает словари, второй кортежи. Работать и с теми, и с другими не так удобно как с экземплярами моделей, дескать, платите ребята за скорость удобством. А я вот не хочу, и благодаря именнованым кортежам из стандартного модуля `collections`, не буду.
Для тех кто не сталкивался и для тех кого пока не убедил, приведу кусочек кода, иллюстрирующий текущее положение вещей:
> `qs = Item.objects.filter(...)
>
> **for** item **in** qs:
>
> **print** item.title, item.amount
>
> total += item.amount \* item.price
>
>
>
> *# используем словари*
>
> qs = Item.objects.filter(...).values('title', 'amount', 'price')
>
> **for** item **in** qs:
>
> **print** item['title'], item['amount']
>
> total += item['amount'] \* item['price']
>
>
>
> *# используем кортежи*
>
> qs = Item.objects.filter(...).values_list('title', 'amount', 'price')
>
> **for** item **in** qs:
>
> **print** item[0], item[1]
>
> total += item[1] \* item[2]`
Варианты со словарями и кортежами не так симпатичны как с моделями, но работают быстрее и требуют меньше памяти. Именованные кортежи позволяют обращаться к своим полям по атрибуту, т.е. с ними наш код будет почти не отличаться от кода для моделей. Отсюда сопутствующий бонус — во многих случаях мы сможем переходить от моделей к кортежам и обратно не меняя кода, а там где его придётся поменять, изменения будут минимальны. Кроме того, кортежи хранят имена полей в классе, а не каждом объекте как словари, поэтому они занимают меньше памяти, что приятно само по себе и будет иметь ещё большее значение если вам придёт в голову складывать результаты запросов в кеш.
#### Что же такое именованные кортежи?
Именованные кортежи появились в питоне 2.6 и представляют собой кортежи, в которых доступ к элементам возможен по заданным атрибутам. Небольшой кусочек кода для демонстрации:
> `**>>>****from** **collections** **import** namedtuple
>
> **>>>**Point = namedtuple('Point', 'x y'.split())
>
> **>>>**p = Point(x=11, y=22) *# создание с помощью именованных*
>
> **>>>**p2 = Point(11, 22) *# ... или позиционных параметров*
>
> **>>>**p1 == p2
>
> True
>
> **>>>**p[0] + p[1] *# индексация*
>
> 33
>
> **>>>**x, y = p *# ... и распаковка как для обычных кортежей*
>
> **>>>**x, y
>
> (11, 22)
>
> **>>>**p.x + p.y *# доступ к элементам через атрибуты*
>
> 33
>
> **>>>**Point._make([11, 22]) *# создание из итерируемого объекта*
>
> Point(x=11, y=22)`
#### NamedTuplesQuerySet
Осталось создать потомок `QuerySet`, который будет выдавать именованные кортежи. Благодаря тому, что вся логика запроса с обозначенными полями реализована в `ValuesQuerySet` (возвращается из `QuerySet.values()`), нам остаётся только обработать результат перед выдачей:
> `**from** **itertools** **import** imap
>
> **from** **collections** **import** namedtuple
>
>
>
> **from** **django.db.models.query** **import** ValuesQuerySet
>
>
>
> **class** **NamedTuplesQuerySet**(ValuesQuerySet):
>
> **def** iterator(self):
>
> *# собираем список имён полей*
>
> extra_names = self.query.extra_select.keys()
>
> field_names = self.field_names
>
> aggregate_names = self.query.aggregate_select.keys()
>
> names = extra_names + field_names + aggregate_names
>
>
>
> *# создаём класс кортежа*
>
> tuple_cls = namedtuple('**%s**Tuple' % self.model.__name__, names)
>
>
>
> results_iter = self.query.get_compiler(self.db).results_iter()
>
> *# заворачиваем каждую строку в наш именованный кортеж*
>
> **return** imap(tuple_cls._make, results_iter)`
И, для удобства использования припишем метод к `QuerySet`:
> `**from** **django.db.models.query** **import** QuerySet
>
>
>
> **def** namedtuples(self, \*fields):
>
> **return** self._clone(klass=NamedTuplesQuerySet, setup=True, _fields=fields)
>
> QuerySet.namedtuples = namedtuples`
После этого код, приведённый в начале статьи, для моделей, словарей и кортежей можно будет записать как:
> `qs = Item.objects.filter(...).namedtuples('title', 'amount', 'price')
>
> **for** item **in** qs:
>
> **print** item.title, item.amount
>
> total += item.amount \* item.price`
Забавно, что получившийся класс выполняет функции обоих имеющихся ускорителей `values()` и `values_list()`. Причём делает это либо лучше, либо почти также и при этом порождает более красивый код. Может, когда-нибудь это приведёт к их замене.
**P.S.** Код класса вместе с патчем можно стянуть отсюда [gist.github.com/876324](https://gist.github.com/876324)
**P.P.S.** Порядок полей в кортеже может не соответствовать порядку аргументов `nametuples()`, забил на это ради скорости. Реализацию переупорядочивания полей, если кому надо, можно взять из `ValuesListQuerySet.iterator()`. | https://habr.com/ru/post/115797/ | null | ru | null |
# Как правильно писать логи (?)
Тема может и банальная, но когда программа начинает работать как то не так, и вообще вести себя очень странно, часто приходится читать логи. И много логов, особенно если нет возможности отлаживать программу и не получается воспроизвести ошибку. Наверно каждый выработал для себя какие то правила, что, как и когда логировать. Ниже я хочу рассмотреть несколько правил записи сообщений в лог, а также будет небольшое сравнение библиотек логирования для языков php, ruby и go. Сборщики логов и системы доставки не будут рассматриваться сознательно (их обсуждали уже много раз).
Есть такая linux утилита, а также по совместительству сетевой протокол под названием syslog. И есть целый набор RFC посвящённый syslog, один из них описывает уровни логирования <https://en.wikipedia.org/wiki/Syslog#Severity_level> (<https://tools.ietf.org/html/rfc5424>). Согласно rfc 5424 для syslog определено 8 уровней логирования, для которых также дается краткое описание. Данные уровни логирования были переняты многими популярными логерами для разных языков программирования. Например, <http://www.php-fig.org/psr/psr-3/> определяет те же самые 8 уровней логирования, а стандартный Ruby logger использует немного сокращённый набор из 5 уровней. Несмотря на формальное указание в каких случаях должен быть использован тот или иной уровень логов, зачастую используется комбинация вроде debug/info/fatal — первый для логирования во время разработки и тестирования, второй и третий в расчёте на продакшен. Потом в какой то момент на продакшене начинает происходить что то не понятное и вдруг оказывается, что info логов не хватает — бежим включать debug. И если они не сильно нагружают систему, то зачастую так и остаются включенными в продакшен окружении. По факту остаётся два сценария, когда нужно иметь логи:
* что-то происходит и надо знать что
* что-то сломалось и нужно дополнительно активировать триггер
По триггеру может происходить: уведомление об ошибке на email, аварийное завершение или перезапуск программы или другие типичные сценарии.
В языке Go в котором всё упрощено до предела, стандартный логер тоже прилично покромсали и оставили следующие варианты:
* Fatal — вывод в лог и немедленный выход в ОС.
* Panic — вывод в лог и возбуждение «паники» (аналог исключения)
* Print — просто выводит сообщение в лог
Запутаться, что использовать в конкретной ситуации уже практически невозможно. Но сообщения в таком сильно усеченном виде сложно анализировать, а также настраивать системы оповещения, типично реагирующих на какой нибудь Alert\Fatal\Error в тексте лога.
Я часто при написании программы с нуля повсеместно использую debug уровень для логирования с расчётом, что на продакшене будет выставлен уровень логирования info и тем самым сократится зашумлённость сообщениями. Но в таком подходе часто возникают ситуация, что логов вдруг становится не хватать. Трудно угадать, какая информация понадобиться, что бы отловить редкий баг. Возможно рационально всегда использовать по умолчанию уровень info, а в обработчиках ошибок уровень error и выше. Но если у вас сотни и больше сообщений лога в секунду, то тогда наверно есть смысл тонкой настройки между info/debug. В таких ситуациях уже имеет смысл использовать специализированные решения что бы не просаживать производительность.
Есть ещё тонкий момент, когда вы пишите что то вроде `logger.debug(entity.values)` — то при выставленном уровне логирования выше debug содержимое entity.values не попадёт в лог, но оно каждый раз будет вычисляться отъедая ресурсы. В Ruby логеру можно передать вместо строки сообщения блок кода: `Logger.debug { entity.values }`. В таком случае вычисления будут происходить только при выставленном соответствующем уровне лога. В языке Go для реализации ленивого вычисления в логер можно передать объект поддерживающий интерфейс Stringer.
После того, как разобрались с использованием уровней логов, нужно ещё уметь связывать разрозненные сообщения, особенно это актуально для многопоточных приложений или связанных между собой отдельных сервисов, когда в логах все сообщения оказываются вперемешку.
Типичный формат строки сообщения в логе можно условно разделить на следующие составные части:
```
[system info] + [message] + [context]
```
Где:
* `system info`: метка времени, ид процесса, ид потока и другая служебная информация
* `message`: текст сообщения
* `context`: любая дополнительная информация, контекст может быть общим для сообщений в рамках какой то операции.
Для того, чтобы связать пары запрос\ответ часто используется http заголовок `X-Request-ID`. Такой заголовок может сгенерировать клиент, или он может быть сгенерирован на стороне сервера. Добавив его в контекст каждой строчки лога появится возможность лёгким движением руки найти все сообщения возникшие в рамках выполнения конкретного запроса. А в случае распределенных систем, заголовок можно передавать дальше по цепочке сетевых вызовов.
Но с единым контекстом в рамках запроса возникает проблема с различными ORM, http клиентами или другими сервисами\библиотеками, которые живут своей жизнью. И ещё хорошо, если они предоставляют возможность переопределить свой стандартный логер хотя бы глобально, а вот выставить контекст для логера в рамках запроса зачастую не реально. Данная проблема в основном актуальна для многопоточной обработки, когда один процесс обслуживает множество запросов. Но например в фрэймворке Rails имеется очень тесная интеграция между всеми компонентами и запросы ActiveRecord могут писаться в лог вместе с глобальным контекстом для текущего сетевого запроса. А в языке Go некоторые библиотеки логирования позволяют динамически создавать новый объект логера с нужным контекстом, выглядит это примерно так:
```
reqLog := log.WithField("requestID", requestID)
```
После этого такой экземпляр логера можно передать как зависимость в другие объекты. Но отсутствие стандартизированного интерфейса логирования (например как psr-3 в php) провоцирует создателей библиотек хардкодить малосовместимые реализации логеров. Поэтому если вы пишите свою библиотеку на Go и в ней есть компонент логирования, не забудьте предусмотреть интерфейс для замены логера на пользовательский.
Резюмируя:
* Логируйте с избытком. Никогда заранее не известно сколько и какой информации в логах понадобится в критический момент.
* Восемь уровней логирования — вам действительно столько надо? По опыту должно хватить максимум 3-4, и то при условии, что для них настроены обработчики событий.
* По возможности используйте ленивые вычисления для вывод сообщений в лог
* Всегда добавляйте текущий контекст в каждое сообщение лога, как минимум requestID.
* По возможности настраивайте сторонние библиотеки таким образом, чтобы они использовали логер с текущим контекстом запроса. | https://habr.com/ru/post/327834/ | null | ru | null |
# Программирование LibreOffice Base. Часть 3
Сегодня мы рассмотрим использование диалоговых окон при редактировании данных в LibreOffice Base (OpenOffice Base). Как мы выяснили в предыдущих сообщениях, Форма LibreOffice Base (OpenOffice Base) — это фактически экземпляр текстового редактора LibreOffice (OpenOffice) Writer. Для организации оконного интерфейса внутри Формы используется Диалоги — которые удобно создаются во встроенным визуальном интерфейсе, но не имеют поддержки для связи с таблицами базы данных. Эту связь будем организовывать макросами OO Basic.
Начнем по-порядку. Создадим две таблицы в базе данных:
products
— id (целое, первичный ключ)
— name (строка)
orders
— id (целое, первичный ключ)
— productId (целое)
— count (целое)
— date (тип данных Дата)
Создадим форму orders, добавим в форму элемент Form с именем orders. А также Table Control с источником данных orders. Как это сделать рассматривалось в [Части 2](https://habr.com/ru/post/445304/) серии сообщений.
При задании свойств колонки date обратите, пожалуйста, внимание на отмеченные на рисунке стрелками свойства, которые позволяют отображать данные в нужном формате и использовать выпадающий календарь для выбора конкретной даты.
**Рисунок**
Теперь прямо в таблице можно добавлять и изменять данные. До определенного момента это удобно, похоже на привычную работу клиента с табличным процессором. Но в какой-то момент начинаются проблемы, также характерные для работы с табличными процессорами. Данные можно изменить случайно, даже не заметив этого. А заметив невозможно откатить все как было. Места для новых колонок мало, и может образоваться неприятная горизонтальная прокрутка. Заголовки колонок также имеют ограничение по размеру (иначе не поместятся по горизонтали), и это не позволяет дать подробное описание данных.
В качестве полумеры можно рядом с таблицей разместить обычные поля для ввода данных (Text Control, Numeric Control и т.д.). В качестве источника данных задать соответствующие поля таблицы orders и все будет работать. При навигации по набору данных будут меняться данные в полях ввода. При изменении данных в полях ввода будут меняться данные в таблице базы данных. Но выглядеть это решение будет не очень красиво.
Поэтому реализуем такой функционал при помощи Диалогов. У Диалогов есть одно существенное ограничение. Поля ввода Диалогов не связаны с таблицей базы данных. Поэтому заполнение полей ввода Диалога из таблицы базы данных, и сохранение полей ввода в таблицу базы данных нужно будет делать макросом OO Basic. Впрочем, это и хорошо, т.к. позволяет рассмотреть возможности программирования OO Basic (до этого в моих сообщениях была описана работа только со средой, но все это было подготовкой к сегодняшнему сообщению).
Чтобы вызвать на экран редактор Диалогов, необходимо выбрать в меню Tools->Macros->Organize Macros->LibreOffice Basic->Organizer->Dialog->New|Edit|Delete. Хотелось бы иметь более быстрый способ добраться до этого редактора. После чего откроется редактор диалога (увы, не самый удобный), в котором мы создадим поля с именами полей таблицы базы данных. Как Вы помните Диалоги не связываются автоматически с таблицами базы данных поэтому мы напишем макрос, который сделает это. И в качестве соглашения об именовании определим имена полей ввода и полей таблицы базы данных одинаковыми.
Редактор с готовой формой будет выглядеть примерно так:
**Рисунок**
Далее, добавим в Диалог две кнопки. Имена кнопкам дадим произвольные, но начинающиеся с подчеркивания, чтобы отличить их от полей базы данных. Каждой кнопке в палитре свойств можно задать действие. Зададим одой кнопке действие OK — она закроет Диалог с подтверждением действия. А второй — Cancel — она закроет диалог без подтверждения действия.
Закроем редактор Диалогов, и вернемся в редактор Формы. Создадим кнопку, вызывающую диалог и назначим ей процедуру-обработчик Order\_Edit, в которой будем заполнять Диалог из таблицы базы данных FromBaseToDialog(oForm, oDialog), и сохранять данные из Диалога таблицу базы данных FromDialogToBase(oDialog, oForm).
```
Sub Order_Edit(Event)
Dim oDialog As Object
Dim orders As Object
orders = Thiscomponent.DrawPage.Forms.GetByName("orders")
DialogLibraries.LoadLibrary("Standard")
oDialog = CreateUnoDialog(DialogLibraries.Standard.dialogOrder)
FromBaseToDialog(orders, oDialog)
If oDialog.Execute() = 1 Then
FromDialogToBase(oDialog, orders)
orders.UpdateRow()
End If
End Sub
Sub FromBaseToDialog(oForm, oDialog)
Dim I
Dim sName As String
For I = 0 To Ubound(oDialog.Model.ElementNames)
sName = oDialog.Model.ElementNames(I)
If Mid(sName, 1, 1) <> "_" And Mid(sName, 1, 5) <> "Label" Then
ODialog.GetControl(sName).SetText(oForm.Columns.GetByName(sName).String)
End If
Next I
End Sub
Sub FromDialogToBase(oDialog, oForm)
Dim I
Dim sName As String
For I = 0 To Ubound(oDialog.Model.ElementNames)
sName = oDialog.Model.ElementNames(I)
If Mid(sName, 1, 1) <> "_" And Mid(sName, 1, 5) <> "Label" Then
oForm.Columns.GetByName(sName).UpdateString(Trim(oDialog.GetControl(sName).GetText()))
End If
Next I
End Sub
```
Предполагается, что Диалог был сохранен в библиотеке Standard под именем dialogOrder. Естественно, Вы можете выбрать другие имена. Имена контролов, начинающиеся с подчеркивания пропускаются и не обрабатываются. Также не обрабатываются имена, начинающиеся с Label, которые используются для текстовых заголовков полей.
Вызов oDialog.Execute() = 1 отображает Диалог внутри окна Формы и приостанавливает работу макроса до нажатия кнопки OK или Cancel. При нажатии на кнопку OK выполнится равенство возвращаемого значения единице. | https://habr.com/ru/post/445640/ | null | ru | null |
# Начинающий программист vs Избирком СПб
*Это история о том, как я писал код на Python 3, который собирает и систематизирует данные по избирательным комиссиям в моём родном городе Санкт-Петербурге. Ну, и про то, что я там накопал в извлечённых данных.*
Интродукция
-----------
С 2018 года я работаю в разных качествах в избирательных комиссиях от одной из наблюдательский организация Санкт-Петербурга. Вношу свой посильный вклад в построение гражданского общества, так скажем. И да, может с учётом контекста сегодняшнего времени, не очень я вовремя с этой статьёй, ну а что поделать.
Интерес к тому, чтобы систематизировать данные по избирательным комиссиям появился у меня в тот момент, когда я участвовал в выборах 2021 года в качестве ЧПРГ ТИК№31. Учиться программировать я стал относительно недавно, 2 месяца в относительно ленивом темпе (на момент начала июня 2022).
3 июня я приступил к работе и начал осуществлять свою давнюю задумку.
S'il vous plait - хронология.
Глава 1. Сбор данных
--------------------
Сайт, с которого я собирал данные [выглядит так](http://www.st-petersburg.vybory.izbirkom.ru/region/st-petersburg?action=ik&vrn=27820001006425).
Слева структура комиссий в открывающихся списках. Честно говоря, я пока что понятия не имею, как устроена веб-страница на практике, но заметил, что если открывать разные комиссии, то сайт остаётся один и тот же, меняется только длинный номер в конце адреса. Я попробовал понять, есть ли какая-нибудь связь между номером комиссии и её номером в адресной строке, но быстро понял, что никакой генеральной закономерности там нет, хоть фрагментами и можно так подумать.
Переписывать ссылки вручную - дело долгое и неблагодарное, поэтому полез в веб-инспектор сафари. Полу-наугад стал там искать, где есть ссылки, на которые ведут номера комиссий. Сначала копался в ресурсах и увидел, что если раскрыть список - появляется файл st-petersburg, в котором перечислены несколько айдишников. Уже неплохо, но всё ещё многовато действий.
Продолжил поиски и во вкладке Аудит нашёл то, что искал, как на ладони (Result Data -> data-domAttributes. Для того, чтобы там появилось всё, что мне надо, пришлось вручную пооткрывать все списки, но это не заняло много времени.
Экспорт был в файл с расширением json. Я что-то об этом слышал, поэтому решил не разбираться (может быть слишком долго), а просто скопировал из окошка строки с айдишниками в обычный текстовый файл.
Также с сайта втупую выделил и скопировал список комиссий в текстовый файл, они там в таком же порядке, как и их айди на картинке, поэтому можно будет составить словарь или типа того.
Глава 2. Очистка данных
-----------------------
Эффективнее было бы очистить числа от html-мусора в любом текстовом редакторе, но это неспортивно, я ж в конце концов программировать учусь, а не текстовым редактором пользоваться.
Немного освежил память, как там обращаться к файлам и написал незамысловатый код для очистки:
```
out_string_indexes = ''
file_name = 'Indexes List.txt'
with open(file_name, mode='r') as file:
for line in file:
if '<' in line: #это чтоб отфильтровать нужные строки, они
# там странновато скопировались
out_string_indexes += line.split('id=')[1].split('"')[1]
out_string_indexes += '\n'
file_name = 'indexes_processed.txt'
with open(file_name, mode='w') as file:
file.write(out_string_indexes)
```
Затем проверил, ничего ли не потерялось:
```
file_name = 'indexes_processed.txt'
with open(file_name, mode='r') as file:
i = 0
for line in file:
i += 1
print('There are {} indexes'.format(i))
file_name = 'commissions_list.txt'
with open(file_name, mode='r') as file:
i = 0
for line in file:
i += 1
print('There are {} commissions in the list’.format(i))
```
Всё оказалось хорошо, выдало по 2017 и тех и других.
> Нашёл в интернете вот это, для тех, что проникся дзеном пайтона
>
> `sum(1 for line in open('file', ‘r’))`
>
> Но я ещё не проникся настолько, побаиваюсь вообще таких функций. Мне лучше для начала понятно и надёжно (как Tegridy farms(r))
>
>
Глава 3. Общение с вебсайтом
----------------------------
С такой проблемой я ещё не сталкивался, поэтому стал читать, как вообще обратиться к вебсайту. Спустя пару минут выяснил, что с помощью urllib.request. Открыл, сразу же столкнулся с такой проблемой:
urllib.error.URLError:
Догадался скопировать ошибку в гугл и быстро нашёл, что нужно в папке пайтона тыкнуть на установку сертификата. Попробовал подсоединиться снова, получил вот это:
raise HTTPError(req.full\_url, code, msg, hdrs, fp)
urllib.error.HTTPError: HTTP Error 403: Forbidden
Упс, кажется, мне тут не рады. А ещё похоже, что он меня по айпи забанил, потому что и через браузер перестал входить, а через терминал пингуется нормально. (апд: потом разбанил через сутки)
Ничего страшного, раздал интернет с телефона. Там, если я что-то в чём-то понимаю, айпи присваивается динамически при подключении, и такая блокировка не сработает, если переподключаться. В интернете я быстро вычитал, что к запросу надо добавить хедер, типа имитировать, что я с браузера захожу.
*Если что, у меня ОЧЕНЬ поверхностные знания обо всём этом.*
```
from urllib.request import Request, urlopen
req = Request('http://www.st-petersburg.vybory.izbirkom.ru/region/st-petersburg?action=ik&vrn=27820001006425',
headers={'User-Agent': 'Mozilla/5.0'})
webpage = urlopen(req).read()
result = webpage.decode('utf-8', 'ignore')
print(result)
```
На этот раз получилось, но получилось всё ещё не то. Если я правильно понял, то страница-то загрузилась, но не выполнился скрипт, который подгружает на страницу все нужные мне данные.
Разумеется, я не единственный, кто с этой проблемой столкнулся, поэтому вновь углубился в чтение. За это время [моим любимым сайтом стал Stack Overflow](https://stackoverflow.com/questions/8049520/web-scraping-javascript-page-with-python).
Собственно, загрузив нужный модуль requests\_html, которых там почему-то сразу загрузилась целая гирлянда, я написал это, и оно наконец сработало! Лёд тронулся, господа присяжные.
```
from requests_html import HTMLSession
session = HTMLSession()
url = 'http://www.st-petersburg.vybory.izbirkom.ru/region/st-petersburg?action=ik&vrn=4784001269007'
r = session.get(url, headers={'User-Agent': 'Mozilla/5.0'})
r.html.render
result = r.text.encode('utf-8')
result = result.decode('utf-8')
print(result)
```
Кодировать и раскодировать пришлось по той причине, что вместо кириллицы он выдавал ерунду, а как ещё декодировать эту хрень - я не догадался, так что прошу прощения, если говнокод. Тем не менее, результата я достиг.
Voila, la HTML pageДело осталось за малым: нужно теперь вытащить оттуда саму табличку и написать программу, которая прогонит этот алгоритм через все 2017 комиссий. Предварительно придумав, каким образом эти данные структурировать, чтобы потом можно было по ним всё что нужно искать.
*Кстати, я тут подумал, может повытаскивать у них адреса и разметить на карте*
Глава 4. Построение программы
-----------------------------
Сначала я писал команды в императивном стиле, чтобы понять, что мне именно нужно и как этого достичь, затем уже распихал всё это по функциям и слепил из них мастер-функцию.
Если кратко описать, то отрезал страницу по начало таблицы, удалил все <штуки>, некоторые заменив на разделители, затем командой split сделал из получившейся строки массив, из которого дальше сделал двумерный массив. Приблизительно так:
```
def text_cleanup(txt=text):
# Обрезаю таблицу
start = txt.index('ФИО') #начало таблицы
txt = txt[start::]
start = txt.find('1') #начало первой нужной строки таблицы
txt = txt[start - 4::]
end = txt.index('', '')
txt = txt.replace('|', '...') #строки
txt = txt.replace(' ', ',,,') #столбцы
txt = txt.replace(' |', '')
txt = txt.replace('', '')
txt = txt.replace('', '')
txt = txt.replace('
', '')
txt = txt.replace('', '')
txt = txt.replace('\r', '')
txt = txt.replace('\t', '')
txt = txt.replace('\n', '')
return txt
```
Дальше так
```
txt = text_cleanup()
result = txt.split(‘…’) #разбиваю текст по строкам
for i in range(len(result)): #разбиваю каждую строку на элементы
result[i] = result[i].split(',,,')
return result
```
И лёгким движением руки таблица с сайта превращается... превращается таблица с сайта... в двумерный массив.
Дальше я создал функцию, которая берёт веб-страницу через session.get и render, как я писал выше, прогоняет полученное через функцию очистки, записывает в текстовый файл или эксель, и всё это в цикле, который из списка подгружает айдишники, которые до этого были в него записаны из файла ещё одной функцией. Как писать в эксель - это я прочитал статью про модуль pyopenxl, мне очень понравилась там функция append, которую я и использовал в своей программе.
Короче, сущностно происходит следующее:
* Из файлов выгружается в двумерный список названия комиссий и их айди
* Циклом по очереди из этого списка читаются айди
* Добавляются к постоянной части адреса, загружается код страницы
* Очищается от мусора и преобразуется в двумерный список
* Построчно вместе с номером комиссии записывается в файл
Код получился здоровый, поэтому публиковать не буду, основные его элементы и логику я в принципе описал. Итого 2 минуты код отработал как часы и на выходе получилась здоровенная таблица!
А вот и я там
> Тут я ненадолго остановлюсь и опишу свои ощущения:
>
> Я хоть и продвинутый, но обычный юзер, поэтому когда вся эта штука сработала - я ощутил себя каким-то, блин, Нео. Вообще то, что я написал программу, которая сама в интернете ковыряется - это крайне странно. Ни разу не выходил в интернет не через браузер. Вот уж был действительно hello world!
>
> И это пока что первая программа, которая выполняет что-то не абстрактное, а вполне конкретное. Собственно, испытываю гордость за себя:)
>
>
Глава 5. Анализ
---------------
В принципе, всю аналитику можно было бы сделать в экселе, но это неспортивно, я же программировать учусь. Какую-то сложную аналитику я производить не буду, меня интересуют довольно простые вещи. Гипотеза в том, что представителей крупных партий кроме Единой России непропорционально мало среди руководства комиссий, а может и в принципе среди всех членов комиссий.
Чтобы мой дорогой читатель не подумал, что я сразу выдумал всю программу, сначала я написал код несколько меня интересующих случаев, но потом решил, что нужно более универсальное и гибкое решение.
Написал сначала функцию analysis(\*args), которая делает вот что:
* создаёт пустой словарь
* считывает из текстового файла строку
* ищет в ней слова из \*args
* если находит, проверяет, есть ли в словаре название партии
* если есть - делает +=1, если нет - добавляет со значением 1
* выдаёт в итоге общее количество найденных строк и словарь, в котором напротив названия партии указано количество человек
Так это выглядело на выходе, если не фильтровать (только без процентов сначала):
Там ещё дальше много строкФильтр работал нормально, но с таким результатом сделать что-то сложно. У меня возникли идеи: надо сделать отдельную функцию фильтр с аргументом, переключающим режимы И / ИЛИ, а также создать список основных партий и сверять с ним, потому что читать данный результат трудно. Можно ещё отметить, что Единая Россия внимательнее всех относится к тому, чтобы написать именно конкретное отделение своей партии.
В итоге следующая версия выглядела так:
parties\_list - это список более крупных партий, который я выделил
```
def filter_keywords(line='', und=False, *args):
"""Returns True if arguments are in line.
Basically, und is and:
If und=True -> every argument must be in line,
If und=False -> at least one argument must be in line"""
if und:
for word in args:
if word.lower() not in line.lower():
return False
return True
else:
for word in args:
if word.lower() in line.lower():
return True
return False
def analysis(unite_minors=True, und=False, *args):
"""Returns vocabulary with parties and a number of members in it and overall quantity of members.
unite_minors collects every minor party/association to keyword 'Остальные'.
und is about filtering style 'and' or 'or', und is and in a nutshell.
args is keywords for filtering"""
result = {'Остальные': 0}
counter = 0
with open('master_table.txt', mode='r') as file:
for line in file:
if filter_keywords(line, und, *args):
party = line.split(' : ')[6]
if not unite_minors: #если не объединять партии, не входящие в список
if party in result:
result[party] += 1
else:
result[party] = 1
counter += 1
else: #если объединять партии, не входящие в список
for major_party in parties_list:
if filter_keywords(line, False, major_party):
if major_party in result:
result[major_party] += 1
else:
result[major_party] = 1
counter += 1
break
else: #если за цикл не нашлось совпадений
counter += 1
result['Остальные'] += 1
# сортировка словаря, скопировал из интернета дзен-функцию
# на этот раз было лень писать самому
result = dict(sorted(result.items(), key=lambda item: item[1], reverse=True))
return result, counter
```
Я решил отправить в return помимо словаря сколько всего строчек обработано. Для учёта и чтоб сразу проценты можно было высчитывать, хотя не знаю, насколько это целесообразно. Но если что - легко переделывается.
Так гораздо лучше, но спустя некоторое количество запросов я понял, что такая функция не позволяет мне узнать, например, кто выдвинул Председателя, Зама и Секретаря только в Территориальных комиссиях. Поэтому решил сделать новую, которая будет фильтровать отдельно по уровню комиссий и должностям. Она стала концептуально проще и принимает строки с ключевыми словами через пробел.
```
def filter_or(line, *args):
for word in args:
if word.lower() in line.lower():
return True
return False
def analysis2(level='', position='', unite_minors=True):
"""Returns vocabulary with parties and a number of members in it and overall quantity of members.
unite_minors collects every minor party/association to keyword 'Остальные'.
level is keywords for level filter, type with spaces between keywords!
position is keywords for position filter, type with spaces between keywords!"""
result = {'Остальные': 0}
counter = 0
level = level.split(' ')
position = position.split(' ')
with open('master_table.txt', mode='r') as file:
for line in file:
t_party = line.split(' : ')[6]
t_position = line.split(' : ')[5]
t_level = line.split(' : ')[0]
if filter_or(t_level, *level) and filter_or(t_position, *position):
if not unite_minors:
if t_party in result:
result[t_party] += 1
else:
result[t_party] = 1
counter += 1
else:
for major_party in parties_list:
if filter_or(t_party, major_party):
if major_party in result:
result[major_party] += 1
else:
result[major_party] = 1
counter += 1
break
else:
counter += 1
result['Остальные'] += 1
result = dict(sorted(result.items(), key=lambda item: item[1], reverse=True))
return result, counter
```
На этот раз я получил весь функционал, который хотел. И да, немного кода, который всё это выводит на консоль. А затем ещё и в графики вместе с модулем matplotlib.pyplot, о котором я только что прочитал.
```
voc, quantity = analysis2(level='спбик тик уик',
position='председатель зам секретарь член',
unite_minors=True)
print('****Всего {}****\n'.format(quantity))
for item in voc:
print('{} or {}% : {}'.format(voc[item],
round(voc[item] / quantity * 100, 1),
item))
values, keys = list(voc.values()), list(voc.keys())
plt.pie(values, labels=keys, autopct='%.1f%%') #так неочевидно процент выводится
plt.title('Винни-Пух и все, все, все')
plt.show()
```
Глава 6. То, ради чего это всё задумывалось
-------------------------------------------
Тут будут таблички и графики с минимальными комментариями.
Если есть желание понять субъект анализа, типа как эти все комиссии устроены и кто в них что делает, то лучше об этом почитать подробнее в любом разделе "Обучение" наблюдательский организаций или даже официальных порталов. А я опишу кратко:
УИК - участковая избирательная комиссия, обеспечивает выборы на местах непосредственно. Принимает всё что нужно для работы от ТИК, отчитывается туда же.
ТИК - территориальная избирательная комиссия, выполняет административно-хозяйственные функции, то есть, грубо говоря, материальная база и вопросы формирования, назначения/освобождения членов нижестоящих комиссий (разумеется через заявления).
Комиссия - коллегиальный орган, право голоса имеют все, вопросы решаются через голосование большинством. Кворум для открытия заседания в общем случае - больше половины.
Председатель - по сути спикер комиссии, должностное лицо
Секретарь - думаю, более-менее и так понятно
Поскольку у комиссий разного уровня сильно разные функции, то и обобщать их особого смысла я не вижу.
Для начала посмотрим, что мы имеем по Участковым избирательным комиссиям:
---
**УИК, все**
По месту работы - это по сути работники бюджетных организаций. По месту жительства в большинстве случаев тоже, ну или близкие к. Возможно среди них есть и просто активные жители, но очень сомневаюсь, что таких там хоть сколько-то много. Думаю, где-то описаны схемы набора таковых, да и догадаться несложно
Остальные - это представители многочисленных организаций, о которых в основном никто никогда и не слышал. Обычно около-административные. (Личная оценка)
Как видно, средняя комиссия наполовину состоит из этих трёх категорий, а партии распределены более-менее ровно с предпочтением к самым крупным.
Теперь посмотрим, а что там в руководстве УИКов.
---
**УИК, Руководство (Председатель, Зам.Председателя и Секретарь)**
Ой, а что это у нас тут случилось? Я думаю, что комментарии тут излишни, а изменения очевидны. Ради интереса можно посмотреть, кто такие эти трудовые партии, союзы труда и партия "За женщин России". У-ух!
Теперь посмотрим, что там по Территориальным комиссиям.
---
**ТИК, Все члены**
Да тут прям почти полноценный плюрализм, мамочки родные!
А теперь руководство ТИК:
---
**Руководство ТИК**
...Ну, что тут сказать можно, картинка достаточно красноречива
---
Очень большой сегмент “Остальные”, я бы посмотрел подробнее, кто у нас там.
```
voc, quantity = analysis2(level='тик',
position='председатель зам секретарь',
unite_minors=False)
print('****Всего {}****\n'.format(quantity))
for item in voc:
print('{} or {}% : {}'.format(voc[item],
round(voc[item] / quantity * 100, 1),
item))
```
32 or 16.9% : собрание избирателей по месту работы
31 or 16.4% : собрание избирателей по месту жительства
**29 or 15.3% : территориальная избирательная комиссия предыдущего состава**16 or 8.5% : Региональное отделение ВСЕРОССИЙСКОЙ ПОЛИТИЧЕСКОЙ ПАРТИИ "РОДИНА" в городе Санкт-Петербурге
16 or 8.5% : Санкт-Петербургское региональное отделение Всероссийской политической партии "ЕДИНАЯ РОССИЯ"
**12 or 6.3% : представительный орган муниципального образования**11 or 5.8% : Региональное отделение в Санкт-Петербурге Политической партии "Российская экологическая партия "Зелёные"
**6 or 3.2% : Санкт-Петербургское региональное отделение политической партии "ПАТРИОТЫ РОССИИ"
4 or 2.1% : Политическая партия "ПАТРИОТЫ РОССИИ"**3 or 1.6% : Региональная общественная организация поддержки и развития молодежного творчества "Гаудеамус"
3 or 1.6% : Санкт-Петербургское региональное отделение Политической партии ЛДПР - Либерально-демократической партии России
3 or 1.6% : ВСЕРОССИЙСКАЯ ПОЛИТИЧЕСКАЯ ПАРТИЯ "РОДИНА"
3 or 1.6% : Политическая партия "Российская экологическая партия "**Зелёные**"
2 or 1.1% : Межрегиональная общественная организация "Ассоциация ветеранов, инвалидов и пенсионеров"
2 or 1.1% : Региональное отделение в Санкт-Петербурге Всероссийской политической партии "ПАРТИЯ РОСТА"
2 or 1.1% : Региональная общественная организация поддержки и развития молодежного творчества "Гуадеамус"
2 or 1.1% : Региональное отделение в Санкт-Петербурге политической партии "НОВЫЕ ЛЮДИ"
1 or 0.5% : Межрегиональная общественная организация "Центр содействия реализации социальных инициатив "Живой Питер"
1 or 0.5% : Региональное отделение в городе Санкт-Петербурге Политической партии "Гражданская Платформа"
1 or 0.5% : Политическая партия "Российская экологическая партия "**Зеленые**"
1 or 0.5% : Санкт-Петербургская региональная общественная организация содействия детям сиротам "Радуга"
1 or 0.5% : САНКТ-ПЕТЕРБУРГСКОЕ ГОРОДСКОЕ ОТДЕЛЕНИЕ политической партии "КОММУНИСТИЧЕСКАЯ ПАРТИЯ РОССИЙСКОЙ ФЕДЕРАЦИИ"
1 or 0.5% : Санкт-Петербургская Региональная Общественная Организация инвалидов "Радонежец"
1 or 0.5% : Местное отделение Санкт-Петербургской общественной организации ветеранов (пенсионеров, инвалидов) войны, труда, Вооруженных сил и правоохранительных органов "Кировское" на территории муниципального округа "Дачное"
1 or 0.5% : Региональная общественная организация инвалидов "Радонежец"
1 or 0.5% : Санкт-Петербургская Общественная Организация в поддержку молодежи "МИР МОЛОДЕЖИ"
1 or 0.5% : Санкт-Петербургская общественная организация "Жители блокадного Ленинграда"
1 or 0.5% : Политическая партия СОЦИАЛЬНОЙ ЗАЩИТЫ
1 or 0.5% : Санкт-Петербургская ассоциация общественных объединений родителей детей-инвалидов “ГАООРДИ"
Я подчеркнул тех, что вошёл как “Остальные”. И ещё заметил, что партия Зелёные вошла тоже туда, потому что для компьютера Е и Ë - разные символы. Надо будет учесть этот момент, хоть он принципиально ни на что и не влияет.
Конечно, я подтолкнул к мысли о том, что не так с этой системой. На самом деле не я, а данные, я их лишь обнажил.
Заключение
----------
Мне очень понравилось, что спустя уже небольшое время я смог применить на практике то, чему научился. Я очень рад, если было хоть немного интересно это занудство читать, если статья открыла какое-то новое виденье, вдохновила, или повлияла ещё каким-то образом.
Открыт для любых дискуссий, пожеланий, советов, критики или чего там ещё. | https://habr.com/ru/post/671832/ | null | ru | null |
# DIY: ретранслятор на micro:bit и радиомодуле LoRa увеличивает дальность связи
В статье «DIY: передаем данные на километры с помощью контроллера Micro::Bit и радиомодуля EBYTE LoRa» ([часть 1](https://habr.com/ru/company/first/blog/669218/) и [часть 2](https://habr.com/ru/company/first/blog/669398/)) мы рассказали, как обеспечить связь на обширных территориях при небольшой излучаемой мощности.
Но что, если нужно передавать данные на расстояния в десятки или даже сотни километров? Например, вдоль таких объектов, как автомобильные дороги, железнодорожные линии или трубопроводы?
Помимо спутников, здесь помогут ретрансляторы, способные принимать данные по радиоканалу и передавать их дальше, до следующего ретранслятора или до конечного узла обмена данными.
Пока, однако, мы не будем решать такие грандиозные задачи, ограничившись увеличением дальности с помощью одного ретранслятора на micro::bit с радиомодулем LoRa EBYTE E32.
Допустим, нам нужно контролировать погоду в парнике из дома, но расстояние между домом и парником такое, что при минимальной мощности радиомодуля 10 мВт надежную связь установить не получается.
Разместим где-нибудь посередине ретранслятор, который будет получать запросы от центрального узла, сделанного на базе Raspberry Pi, и передавать их в парник на узел micro::bit. Данные измерений в парнике будут передаваться обратно на центральный узел опять же через ретранслятор (рис. 1).
Рис. 1. Архитектура системы сбора данных с ретрансляторомМакет системы сбора данных с ретранслятором показана на рис. 2.
Рис. 2. Макет системы сбора данных с ретрансляторомЗдесь мы использовали те же самые блоки, что и для системы с архитектурой «звезда» из [прошлой статьи](https://habr.com/ru/company/first/blog/669218/), изменив только программное обеспечение.
Центральный узел создан на базе Raspberry Pi, а ретранслятор и узел для парника — на базе micro::bit.
Конфигурацию радиомодулей E32 мы оставили прежней. Все радиомодули в наших примерах будут работать на канале 15, а их адреса приведены в табл. 1.
**Табл. 1. Адреса радиомодулей**
| | |
| --- | --- |
| **Узел** | **Адрес** |
| Центральный узел | 14 (0x0E) |
| Ретранслятор | 13 (0x0D) |
| Парник | 12 (0x0C) |
Разумеется, для ретранслятора и парника можно использовать другой номер канала. Более того, центральный и периферийный узел могут передавать данные на одном канале, а ретранслятор — на другом. При выборе номеров каналов следует учитывать, какие частоты разрешены к использованию в вашей стране без лицензии, либо оформить соответствующие документы.
### Узел ретранслятора
Программу micro::bit для ретранслятора, как и все программы из этой статьи, можно загрузить с сайта GitHub по адресу <https://github.com/AlexandreFrolov/loranet>.
Файл с программой для ретранслятора называется microbit-pxt-lora-repeater.hex, а файл программы для парника — microbit-lora-net-host2r.hex.
Программа ретранслятора очень проста. На этапе инициализации она задает параметры подключения и работы радиомодуля E32, а также устанавливает размер буферов передачи данных для UART.
После инициализации на светодиодной матрице micro::bit зажигается буква «R», идентифицирующая узел ретранслятора (рис. 3).
Рис. 3. Блок инициализации ретранслятораКогда центральный узел отправляет в ретранслятор команду «getRData», блок ретранслятора передает по радиоканалу команду «getData» на узел парника с адресом 12 и рисует на мониторе micro::bit стрелку, направленную на сервер. После этого на монитор выводится буква «R» (рис. 4).
Рис. 4. Блок on e32radio received ретранслятораВ ответ на команду «getData», отправленную на узел парника, ретранслятор получает от этого узла данные измерений. Они не содержат строку «getRData» и отправляются ретранслятором в неизменном виде на центральный узел с адресом 14.
Как только данные будут отправлены, на мониторе ретранслятора на короткое время появится стрелка, направленная на юг, а затем ее сменит буква «R».
Таким образом, наш ретранслятор передает в одну сторону (в парник) команду «getRData», а затем в другую строну (на центральный узел) данные измерений в парнике.
Ретранслятор ничего не знает о структуре и размере передаваемых данных, за это отвечает центральный узел и узел парника.
### Узел парника
Узел парника практически полностью аналогичен периферийным узлам из упомянутой выше статьи. Изменения касаются только ПО для micro::bit.
На этапе инициализации выполняются действия, необходимые для работы с радиомодулем и последовательным портом, после чего на монитор выводится буква «B» (рис. 5).
Рис. 5. Блок инициализации узла парникаКогда от ретранслятора в узел парника поступает команда «getData», соответствующий блок вызывает функцию getWeatherData, возвращающую результаты измерений погоды. Далее полученные от этой функции данные отправляются в узел ретранслятора на 15 канале по адресу 13 (рис. 6).
Рис. 6. Блок on e32radio received парникаФункция getWeatherData получает данные от погодной станции BME-280, преобразует их в текстовые строки и соединяет через символ точки с запятой (рис. 7).
Рис. 7. Функция getWeatherData### Центральный узел
В предыдущей статье в центральном узле работала программа, отправляющая в цикле команду «getData» на все периферийные узлы, затем она записывала полученные от них данные измерений в JSON-файл.
Теперь центральный узел обращается к периферийному узлу через ретранслятор. Программа [e32-loranet-repeater.py](https://github.com/AlexandreFrolov/loranet/blob/main/py/e32-loranet-repeater.py) отправляет в узел ретранслятора команду «getRData», а полученные от ретранслятора данные измерений записывает в JSON-файл (листинг 1).
Листинг 1. Файл https://github.com/AlexandreFrolov/loranet/blob/main/py/e32-loranet-repeater.py
```
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import RPi.GPIO as GPIO
import serial
import time
import sys
from time import sleep
import json
NODE_ADDR_CHAN = [b'\x00\x0B\x0F',
b'\x00\x0C\x0F',
b'\x00\x0D\x0F']
def gpio_init ():
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
M0 = 22
M1 = 27
GPIO.setup(M0,GPIO.OUT)
GPIO.setup(M1,GPIO.OUT)
GPIO.output(M0,GPIO.LOW)
GPIO.output(M1,GPIO.LOW)
time.sleep(1)
ser = serial.Serial("/dev/serial0", 9600, timeout=1)
ser.flushInput()
return ser
def send_cmd(node):
try :
if ser.isOpen() :
ser.write(NODE_ADDR_CHAN[node])
ser.write('getRData \n'.encode())
except :
if ser.isOpen() :
ser.close()
GPIO.cleanup()
while ser.inWaiting() == 0:
sleep(0.03)
data_left = ser.inWaiting()
received_data = ser.readline()
sleep(0.03)
received_data += ser.read(data_left)
rec = received_data.decode("utf-8").strip()
node_data = rec.split(';')
return node_data
def format_node_data(node, node_data):
NODE_1_2_ITEMS = ['Температура',
'Давление',
'Влажность',
'Точка росы']
NODE_3_ITEMS = ['Температура CPU',
'Интенсивность освещения']
node_dict={}
i=0
for val in node_data:
val = str(val)
if(node == 0 or node == 1 or node == 2):
node_dict[NODE_1_2_ITEMS[i]]= val
else:
node_dict[NODE_3_ITEMS[i]]= val
i = i+1
return node_dict
def get_nodes_data():
nodes_dict={}
node = 2
node_data = send_cmd(node)
nodes_dict[node] = format_node_data(node, node_data)
return nodes_dict
def save_nodes_data_to_file(nodes_dict):
jsonString = json.dumps(nodes_dict, indent=2, ensure_ascii=False)
print(jsonString)
with open('hosts_data.json', 'w') as f:
json.dump(nodes_dict, f, indent=2, ensure_ascii=False)
ser = gpio_init()
nodes_dict = get_nodes_data()
save_nodes_data_to_file(nodes_dict)
```
По сравнению с ПО центрального узла из предыдущей статьи, основные изменения коснулись функции send\_cmd.
Время ожидания ответа от периферийного узла, передаваемого через ретранслятор, может быть относительно большим. Программа дожидается ответа в бесконечном цикле:
```
while ser.inWaiting() == 0:
sleep(0.03)
```
Когда в устройстве serial появляются данные, они считываются и декодируются, после чего возвращаются в виде строки со значениями, разделенными символом «точка с запятой»:
```
data_left = ser.inWaiting()
received_data = ser.readline()
sleep(0.03)
received_data += ser.read(data_left)
rec = received_data.decode("utf-8").strip()
node_data = rec.split(';')
return node_data
```
Как и в программе из предыдущей статьи, функция save\_nodes\_data\_to\_file записывает данные в файл hosts\_data.json, а также выводит на консоль:
```
$ python e32-loranet-repeater.py
{
"2": {
"Давление": "993",
"Точка росы": "4",
"Влажность": "24",
"Температура": "24"
}
}
```
### Идеи для развития проекта
В каком направлении вы можете развивать свой учебный проект с ретранслятором?
#### Добавьте больше ретрансляторов
Прежде всего, можно добавить еще ретрансляторов, увеличив таким образом общее расстояние, на котором будет возможно получать данные измерений. На рис. 8 показана схема с использованием двух ретрансляторов.
Рис. 8. Добавляем второй ретрансляторМожно сделать так, чтобы первый ретранслятор передавал команду «getRData» на второй узел ретранслятора, установленный в гараже с адресом 12. Второй ретранслятор, в свою очередь, будет передавать эту команду дальше, узлу сбора данных в парнике с адресом 11 (табл. 2).
**Табл. 2. Адреса радиомодулей**
| | |
| --- | --- |
| **Узел** | **Адрес** |
| Центральный узел | 14 (0x0E) |
| Ретранслятор в летнем домике | 13 (0x0D) |
| Ретранслятор в гараже | 12 (0x0C) |
| Парник | 11 (0x0B) |
При передаче данных в обратную сторону узел из парника должен передавать данные на ретранслятор в гараже по адресу 12.
#### Передавайте данные измерений с ретрансляторов
Еще одна идея, которую вы можете реализовать, заключается в том, чтобы ретрансляторы не просто передавали данные в направлении центрального узла, а добавляли к ним результаты собственных измерений.
Например, узлы ретранслятора могут добавлять в данные температуру процессора в микрокомпьютере или данные погодной станции, установленной в ретрансляторе. Разумеется, нужно правильно отделить эти данные в общем потоке, а в программе, работающей на центральном узле, правильно их обработать.
#### Используйте антенны с большим усилением или направленные антенны
Существенно увеличить дальность при той же мощности можно с помощью антенн, обладающих большим усилением или направленных антенн.
Однако в том, что касается направленных антенн, не все так просто. Было бы идеально на узле ретранслятора подключить две такие антенны, направленные в разные стороны, каждая на свой ретранслятор или узел.
Но подключение двух радиомодулей с интерфейсом UART к одному micro::bit проблематично. Такую задачу можно решить с использованием радиомодулей LoRa с интерфейсами SPI или I2C.
Второй вариант — использовать в узле ретранслятора два микрокомпьютера micro::bit, к каждому из которых подключен радиомодуль LoRa. При этом данные между микрокомпьютерами можно передавать с помощью встроенного в micro::bit модуля Bluetooth.
Если у вас появятся еще какие-нибудь идеи по использованию ретрансляторов, расскажите о них в комментариях к этой статье!
*Автор: Александр Фролов.*
---
НЛО прилетело и оставило здесь промокод для читателей нашего блога:— [15% на все тарифы VDS](https://firstvds.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=vds15exeptprogrev) (кроме тарифа Прогрев) — HABRFIRSTVDS. | https://habr.com/ru/post/670052/ | null | ru | null |
# Прошивка esp32 — по воздуху, через wi-fi
Каждый, кто хоть раз занимался хобби-проектами на основе микроконтроллеров, знает, что такая идея проходит множество итераций, прежде чем ~~займёт своё законное место на пыльной полке~~ будет служить верой и правдой.
Обновление программного обеспечения при этом довольно часто становится одной из основных задач. В этой статье мы попробуем испытать способ, который позволит любому разработчику обновлять своё программное обеспечение легко и просто — прямо через сеть wi-fi! При этом задача существенно облегчится, если мы возьмём для экспериментов замечательный микроконтроллер esp32, так как он уже имеет в своём составе wifi-адаптер.
Обновление по воздуху (англ. over-the-air, OTA) предполагает разные методы распространения новых версий программ, настроек и обновлений ключей шифрования для телефонов, ресиверов и устройств зашифрованной передачи речи (двухканальные рации с шифрованием).
Что же касается esp32, то обновление по воздуху является весьма интересной «фишкой», так как позволяет обновлять программу на устройствах, доступ к которым осложнён или невозможен. Например, если устройство расположено где-то высоко (на дереве или фонарном столбе).
Интересным моментом такого рода обновлений является возможность постоянно апдейтить приложения на целой сети устройств, используя для этого центральный сервер с программным обеспечением.
Давайте попробуем реализовать нечто подобное.
Заранее хочу оговориться, что все необходимые файлы находятся внизу под статьёй, и вы можете скачать их по предложенным ссылкам. Все материалы полностью рабочие и протестированы лично.
Сначала нам необходимо зайти на официальный сайт и скачать python версии 2.7.15. Возможно, будет работать и с другой версией, но я пробовал только с этой. Я скачивал 64-битную версию под windows 7 (вот такой я ретроград! :-) ).
Далее вам необходимо установить её на компьютер для всех пользователей:
На следующем шаге необходимо выбрать опцию, как я показал на рисунке ниже:
Проблема в том, что изначально плата esp32 совсем не обладает функционалом для обновления программ по воздуху, поэтому нам необходимо выбрать из примеров опцию ArduinoOTA, как показано ниже:
Далее в предложенный ниже код мы должны вставить название своей точки доступа, к которой мы будем подключаться, а также её пароль. После чего прошьём этим скетчем свою плату:
```
#include
#include
#include
#include
const char\* ssid = "testNet";
const char\* password = "parole";
void setup() {
Serial.begin(115200);
Serial.println("Booting");
WiFi.mode(WIFI\_STA);
WiFi.begin(ssid, password);
while (WiFi.waitForConnectResult() != WL\_CONNECTED) {
Serial.println("Connection Failed! Rebooting...");
delay(5000);
ESP.restart();
}
ArduinoOTA
.onStart([]() {
String type;
if (ArduinoOTA.getCommand() == U\_FLASH)
type = "sketch";
else // U\_SPIFFS
type = "filesystem";
// NOTE: if updating SPIFFS this would be the place to unmount SPIFFS using SPIFFS.end()
Serial.println("Start updating " + type);
})
.onEnd([]() {
Serial.println("\nEnd");
})
.onProgress([](unsigned int progress, unsigned int total) {
Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
})
.onError([](ota\_error\_t error) {
Serial.printf("Error[%u]: ", error);
if (error == OTA\_AUTH\_ERROR) Serial.println("Auth Failed");
else if (error == OTA\_BEGIN\_ERROR) Serial.println("Begin Failed");
else if (error == OTA\_CONNECT\_ERROR) Serial.println("Connect Failed");
else if (error == OTA\_RECEIVE\_ERROR) Serial.println("Receive Failed");
else if (error == OTA\_END\_ERROR) Serial.println("End Failed");
});
ArduinoOTA.begin();
Serial.println("Ready");
Serial.print("IP address: ");
Serial.println(WiFi.localIP());
}
void loop() {
ArduinoOTA.handle();
}
```
Дальше вам будет необходимо запустить монитор порта, предварительно выбрав сам порт, к которому подключена плата и который мы будем мониторить.
Если кто не знает, делается это так, как показано на картинке ниже, то есть можно выбрать среди доступных COM-портов тот самый, к которому у вас подключена esp32. Скорее всего, у вас там будет отображаться несколько портов, один из которых — ваш нужный. Ничего страшного, если вы немного «потыкаетесь» и найдёте методом тыка нужный порт. Однако, если вы хотите поступить более правильным образом, следует нажать на значок компьютера на рабочем столе (повторяю, у меня – Win’7) правой кнопкой мыши и пройти по пути, как показано ниже. Таким образом вы сможете выяснить порт, к которому подключена у вас esp32, это нужно, чтобы вы знали, какой порт необходимо мониторить.
Если в мониторе порта ничего не показывается — то вам необходимо нажать на кнопку «EN» на плате esp32, что приведёт к перезагрузке платы, и в монитор порта выведется вся необходимая информация.
Если всё прошло успешно, то в конце этой информации будет показан IP-адрес, который был выдан вашей плате точкой доступа wi-fi, к которой плата подключилась:
Теперь мы внесём изменения в этот скетч, чтобы при его повторной загрузке в плату, что-то происходило. Например, сделаем так, чтобы встроенный в плату светодиод мерцал с некоторым интервалом.
Для этого в приведённый выше код были внесены некоторые изменения, которые показаны на рисунке ниже:
Сам изменённый код будет выглядеть следующим образом:
```
#include
#include
#include
#include
const char\* ssid = "testNet";
const char\* password = "parole";
//переменные для мигания светодиодом через millis
const int led = 2;
unsigned long previousMillis = 0;
const long interval = 1000;
int ledState = LOW;
void setup() {
pinMode(led, OUTPUT);
Serial.begin(115200);
Serial.println("Booting");
WiFi.mode(WIFI\_STA);
WiFi.begin(ssid, password);
while (WiFi.waitForConnectResult() != WL\_CONNECTED) {
Serial.println("Connection Failed! Rebooting...");
delay(5000);
ESP.restart();
}
ArduinoOTA
.onStart([]() {
String type;
if (ArduinoOTA.getCommand() == U\_FLASH)
type = "sketch";
else // U\_SPIFFS
type = "filesystem";
// NOTE: if updating SPIFFS this would be the place to unmount SPIFFS using SPIFFS.end()
Serial.println("Start updating " + type);
})
.onEnd([]() {
Serial.println("\nEnd");
})
.onProgress([](unsigned int progress, unsigned int total) {
Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
})
.onError([](ota\_error\_t error) {
Serial.printf("Error[%u]: ", error);
if (error == OTA\_AUTH\_ERROR) Serial.println("Auth Failed");
else if (error == OTA\_BEGIN\_ERROR) Serial.println("Begin Failed");
else if (error == OTA\_CONNECT\_ERROR) Serial.println("Connect Failed");
else if (error == OTA\_RECEIVE\_ERROR) Serial.println("Receive Failed");
else if (error == OTA\_END\_ERROR) Serial.println("End Failed");
});
ArduinoOTA.begin();
Serial.println("Ready");
Serial.print("IP address: ");
Serial.println(WiFi.localIP());
}
void loop() {
ArduinoOTA.handle();
unsigned long currentMillis = millis();
if (currentMillis - previousMillis >= interval) {
previousMillis = currentMillis;
ledState = not(ledState);
digitalWrite(led, ledState);
}
}
```
Загрузим этот код в нашу плату. И тут возникает один очень интересный момент: у вас в списке COM-портов появляется сетевой порт, имеющий IP адрес — это и есть наша плата esp32!
Выберем её и нажмём на загрузку скетча. В результате в нижнем окошке появится следующий статус происходящего: будет увеличиваться в длину индикатор загрузки и расти процент:
Кстати сказать, во время этой загрузки у меня плата была подключена к power-банку, т.е. была отключена от компьютера, и загрузка производилась непосредственно через сеть wi-fi.
Ну вот и всё в целом.
В качестве небольшого примечания следует сказать, что код, поддерживающий беспроводную загрузку (первый кусок кода в этой статье), должен быть всегда включён в ваш скетч (который выполняет какую-либо полезную деятельность для вас). Если этого не сделать, то вы потеряете возможность загружать скетчи «по воздуху».
P.S. Если кого-то интересует прошивка по воздуху предыдущей версии платы (esp8266), то [вот тут](http://samopal.pro/arduino-esp8266/) есть весьма подробный мануал.
#### Загрузки:
* [скетчи в архиве](https://drive.google.com/file/d/1U7S1QZSKFme5sG1bNkvNL-JU0U2GrPpj/view?usp=sharing)
* [python 2.7.15](https://drive.google.com/file/d/1CY3vK6zSgoTG7eGxpH61EPtmoKqqMlTC/view?usp=sharing)
Делитесь интересными проектами в комментариях.
---
НЛО прилетело и оставило здесь промокод для читателей нашего блога:
— [15% на все тарифы VDS](https://firstvds.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=vds15exeptprogrev) (кроме тарифа Прогрев) — **HABRFIRSTVDS**. | https://habr.com/ru/post/654623/ | null | ru | null |
# Как заменить container runtime в Kubernetes
Братцы! Скорее всего вы уже знаете, что Kubernetes отказался от поддержки Docker в качестве среды выполнения контейнеров (container runtime) в будущих версиях. В релизе 1.20, вышедшем в конце 2020 года [Dockershim](https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG/CHANGELOG-1.20.md#dockershim-deprecation) помечен как устаревший (deprecated). В релизе 1.22, выход которого запланирован на конец 2021 года, от его поддержки планируют полностью отказаться.
Если вы используете управляемые кластеры Kubernetes (такие как GKE, EKS, AKS) это не станет для вас серьезной проблемой и скорее всего переключение будет простым. Но если вы управляете кластером самостоятельно (например, с помощью [kubeadm](https://github.com/kubernetes/kubeadm)) и используете Docker container runtime, рано или поздно, вам придется заменить ее, чтобы иметь возможность обновлять Kubernetes до последних версий.
Задача этой статьи не дать исчерпывающую информацию о причинах такого решения со стороны разработчиков Kubernetes или подробно изучить поведения конкретных container runtime в кластере Kubernetes. Вместо этого мы шаг за шагом разберемся как переключить Docker container runtime на другое решение, поддерживающее стандарт Container Runtime Interface ([CRI](https://kubernetes.io/blog/2016/12/container-runtime-interface-cri-in-kubernetes/)). Если вас интересуют причины из-за которых Docker больше не рекомендован к использованию, ознакомьтесь со статьей из официального блога Kubernetes [Don't Panic: Kubernetes and Docker](https://kubernetes.io/blog/2020/12/02/dont-panic-kubernetes-and-docker/).
> **Чтобы не пропустить новые статьи подписывайтесь на телеграм-канал** [**Mops DevOps**](https://t.me/devops_mops)
>
>
Что проверять в первую очередь
------------------------------
Влияние на рабочие нагрузки, выполняемые в вашем кластере, должно быть минимальным. Единственное, о чем вам нужно позаботиться, - это используете ли вы Docker-in-Docker в любой из ваших контейнерных рабочих нагрузок, смонтировав сокет Docker /var/run/docker.sock. В этом случае вам нужно будет найти альтернативу (например, [Kaniko](https://github.com/GoogleContainerTools/kaniko)), прежде чем переключаться с Docker на новую container runtime.
Также настоятельно рекомендуется сделать резервную копию ваших данных, прежде чем переходить к переключению среды выполнения контейнера!
Приступим к работе!
-------------------
Отлично, теперь, когда вы готовы к переключению container runtime, можно начинать. В этой статье будем использовать [containerd](https://github.com/containerd/containerd) в качестве container runtime, но приведенные ниже шаги можно адаптировать к другой среде выполнения контейнера, например, [CRI-O](https://github.com/cri-o/cri-o).
Мы начнем с рабочих узлов (worker nodes) и только потом выполним аналогичные действия на мастерах (control plane).
Worker nodes
------------
Указанные ниже шаги нужно выполнить **на всех** рабочих узлах кластера.
1) Вначале выполним `drain` и `cordon` узла кластера, чтобы эвакуировать нагрузки с него и предотвратить планирование новых нагрузок во время выполнения последующих операций:
```
kubectl cordon
kubectl drain
```
Замечание: если на узлах кластера запущены DaemonSets, необходимо использовать флаг `--ignore-daemonsets`, чтобы продолжить эвакуацию остальных pods. Не волнуйтесь kubelet эти pods автоматически пересоздаст с помощью новой container runtime, когда процедура переключения будет завершена. Если у вас есть критические сервисы, запущенные в DaemonSet, и вы не хотите, чтобы они работали во время процесса переключения, вы можете либо указать `nodeSelector` в своем DaemonSet, либо полностью удалить и переустановить их в конце процесса.
2) Останавливаем сервис kubelet:
```
sudo systemctl stop kubelet
sudo systemctl status kubelet
```
3) Удаляем Docker
Я не буду подробно описывать команды, поскольку это зависит от вашего дистрибутива Linux и способа установки Docker. Просто будьте осторожны, если вы хотите полностью очистить артефакты Docker, возможно, вам придется вручную удалить некоторые файлы (например, /var/ lib/docker).
Подробную инструкцию вы найдете в [документации Docker](https://docs.docker.com/engine/install/).
4) Устанавливаем countainerd используя официальное [руководству](https://containerd.io/docs/getting-started/) для вашей версии операционной системы.
5) Выполняем `Enable` и `Start` сервиса containerd:
```
sudo systemctl enable containerd
sudo systemctl start containerd
sudo systemctl status containerd
```
6) Kubernetes взаимодействует с container runtime через плагин CRI . Убедитесь, что этот плагин не был отключен при установке containerd.
Проверим параметр в файле конфигурации /etc/containerd/config.toml
```
disabled_plugins = [""]
```
Если на предыдущем шаге внесены изменения в конфигурационный файл, необходимо перезагрузить сервис containerd:
```
sudo systemctl restart containerd
```
7) Отредактируем конфигурационный файл kubelet.
Добавим в конфигурационный файл /var/lib/kubelet/kubeadm-flags.env флаги для переменной KUBELET\_KUBEADM\_ARGS (при необходимости измените путь к container runtime):
```
--container-runtime=remote --container-runtime-endpoint=/run/containerd/containerd.sock
```
8) Запускаем сервис kubelet:
```
sudo systemctl start kubelet
```
9) Проверяем, что на узле запущена требуемая версия container runtime:
```
kubectl describe node
```
```
System Info:
Machine ID: 21a5dd31f86c4
System UUID: 4227EF55-BA3BCCB57BCE
Boot ID: 77229747-9ea581ec6773
Kernel Version: 3.10.0-1127.10.1.el7.x86_64
OS Image: Red Hat Enterprise Linux Server 7.8 (Maipo)
Operating System: linux
Architecture: amd64
>>Container Runtime Version: containerd://1.4.3
Kubelet Version: v1.20.2
Kube-Proxy Version: v1.20.2
```
10) Выполняем Uncordon на узле, чтобы разрешить планировать на него нагрузки, и проверим статус работы pods:
```
kubectl uncordon
```
Вот и все, как только все ваши поды будут перезапущены, вы можете перейти к настройке следующего узла кластера!
### Control Plane
Процедура обновление container runtime на мастерах полностью повторяет установку на рабочих узлах кластера. Однако будьте осторожны, если ваш кластер запущен с единственным мастером.
Пока новая container runtime будет загружать образы kube-apiserver, etcd и coredns и создавать соответствующие pods, кластер будет недоступен. У вас также не должно быть возможности запускать команду kubectl.
Вот несколько советов, которые помогут вам следить за запуском container runtime и устранять потенциальные проблемы:
1) Используем journalctl, чтобы отслеживать изменения в журналах kubelet:
```
journalctl -u kubelet
```
2) Проверяем журналы containerd:
```
journalctl -u containerd
```
3) Используем утилиту crictl, чтобы убедится, что контейнеры запущены:
```
crictl --runtime-endpoint /run/containerd/containerd.sock ps
```
4) После замены container runtime убедимся, что используем требуемую версию, выполнив команду на всех узлах кластера:
```
kubectl describe node
также можем выполнить команду, она выведет информацию сразу по всем узлам кластера
kubectl get node -o wide
```
**Поздравляю!** Кластер Kubernetes настроен без Docker, теперь проблем с обновлением на новые версии возникнуть не должно.
---
> **Телеграм-канал** [**Mops DevOps**](https://t.me/devops_mops) **- анонсы вебинаров и конференций, полезные статьи и видео, а также регулярные скидки на обучение!**
>
> | https://habr.com/ru/post/546940/ | null | ru | null |
# Удобный Backup
Как известно, в Asus Eee и других нетбуках нет сидирома, а посему а делать загрузочную флешку от Acronis'а как-то не улыбается.
Но есть два простых способа сделать образ диска.
Оба способа требуют загрузки любой Linux-системы (с флешки) и прав суперпользователя для исполнения (то бишь *sudo* для Ubuntu и *su* для всех остальных)
1. `> dd if=/dev/sda1 of=/media/disk/backup.bck`
2. `> cat /dev/sda1 | gzip > /media/disk/backup.bck.gz`
В примерах */dev/sda1* — резервируемый раздел, а */media/disk/* — флешка.
Соответственно, второй способ несколько удобнее за счет сжатия. А первый — заметно быстрее.
Восстановление: в первом случае поменять местами аргументы, а во втором — использовать команду *zcat*.
*Идеи почерпнуты в блоге [Telegamochka](http://telegamochka.livejournal.com) и комментарии [Moose\_kazan](http://moose-kazan.livejournal.com/) там же. Проверены на моем MSI Wind.* | https://habr.com/ru/post/45265/ | null | ru | null |
# Топ VSCode расширений, которые ускорят вашу разработку на JavaScript
[VSCode](https://code.visualstudio.com/) — это кроссплатформенный редактор с открытым исходным кодом, ставший любимым среди программистов, особенно среди веб-разработчиков. Он быстрый, расширяемый и имеет массу возможностей и настроек. Если вы до сих пор не работали с ним, то советую попробовать.
Для VSCode созданы тысячи расширений. Я намерен представить несколько из них, которые использую каждый день. **Приступим!**
Quokka.js
---------
[Quokka.js](https://quokkajs.com/) — это плагин для JavaScript и TypeScript, который **отображает результаты выполнения кода в редакторе, непосредственно во время его написания**. Попробуйте сами!
Установив [расширение](https://marketplace.visualstudio.com/items?itemName=WallabyJs.quokka-vscode), нажмите *Ctrl/Cmd(⌘) + Shift + P*, чтобы запустить палитру команд редактора, и затем введите *Quokka*, чтобы увидеть список доступных команд плагина. Выберите и запустите команду **New JavaScript File** или нажмите *⌘ + K + J*, чтобы создать новый файл. Любой введенный код будет выполнен немедленно.
*Quokka.js*
**Похожие расширения:**
* [Code Runner](https://marketplace.visualstudio.com/items?itemName=formulahendry.code-runner) — поддерживает множество языков (C, C++, Java, JavaScript, PHP, Python, Perl, Perl 6 и другие);
* [Runner](https://marketplace.visualstudio.com/items?itemName=mattn.Runner).
Bracket Pair Colorizer & Indent Rainbow
---------------------------------------
Квадратные и круглые скобки — неотъемлемая часть многих языков программирования. В таком языке как Javascript, **простая станица может иметь целый поток этих символов, среди которых тяжело отличить пары открытых и закрытых скобок**. В этот момент на помощь приходят [Bracket Pair Colorizer](https://marketplace.visualstudio.com/items?itemName=CoenraadS.bracket-pair-colorizer) и [Indent Rainbow](https://marketplace.visualstudio.com/items?itemName=oderwat.indent-rainbow). Это два разных расширения. Однако, вместе они представляют отличную комбинацию. Эти расширения наполнят ваш редактор морем красок, сделают блоки кода отличимыми друг от друга и придадут им приятный вид.
*Без Bracket Pair Colorizer и Indent Rainbow*
*Установив Bracket Pair Colorizer и Indent Rainbow*
Сниппеты
--------
Сниппеты — это сокращения в редакторе, трансформируемые в полноценный код. Вместо `import React from 'react';` пишем `imr` и жмем Tab, чтобы развернуть сниппет. В частности, `clg` разворачивается в `console.log`.
**Существует множество сниппетов для разных направлений**: JavaScript (или другие языки), React, Redux, Angular, Vue, Jest. Лично я считаю JavaScript сниппеты очень полезными, особенно с тех пор как начал работать преимущественно с JS.
**Несколько хороших расширений со сниппетами:**
* [JavaScript (ES6) code snippets](https://marketplace.visualstudio.com/items?itemName=xabikos.JavaScriptSnippets);
* [React-Native/React/Redux snippets for es6/es7](https://marketplace.visualstudio.com/items?itemName=EQuimper.react-native-react-redux);
* [React Standart Style code snippets](https://marketplace.visualstudio.com/items?itemName=TimonVS.ReactSnippetsStandard).
Todo Highlighter
----------------
Часто бывает, написав функцию, вы понимаете, что есть лучший способ написать то же самое. Вы оставляете комментарий `// TODO: Необходим рефакторинг`, но затем забываете об этом и выкладываете код в production. C [Todo Highlighter](https://marketplace.visualstudio.com/items?itemName=wayou.vscode-todo-highlight) подобного не произойдет.
Плагин выделяет TODO/FIXME или другие комментарии в яркие цвета, что довольно тяжело не заметить. Модное нововведение Todo Highlighter — список выделенных комментариев, который выводится в консоли.
*Todo Highlighter*
**Похожие расширения:**
* [Todo+](https://marketplace.visualstudio.com/items?itemName=fabiospampinato.vscode-todo-plus) — более мощный плагин, с множеством новых возможностей;
* [Todo Parser](https://marketplace.visualstudio.com/items?itemName=minhthai.vscode-todo-parser).
Import Cost
-----------
Это [расширение](https://marketplace.visualstudio.com/items?itemName=wix.vscode-import-cost) позволяет увидеть размер импортируемых модулей. **Вы сможете понять, в каком месте вы импортируете библиотеку целиком, а в каком конкретную ее часть**. Это окажет неоценимую помощь со сборкой проекта в Webpack.
*Import Cost*
Rest Client
-----------
Веб-разработчики часто взаимодействуют с различного рода REST API. Для изучения ссылок и проверки ответов на запрос, применяют такие инструменты как [Postman](https://www.getpostman.com/apps). Так зачем использовать отдельное приложение, когда можно то же самое сделать в редакторе? Поприветствуйте [Rest Client](https://marketplace.visualstudio.com/items?itemName=humao.rest-client). **Он позволяет отправлять HTTP-запросы и просматривать ответ непосредственно в Visual Studio Code**.
*Rest Client*
Auto Close Tag & Auto Rename Tag
--------------------------------
С приходом React и той популярностью, которую он набрал за последние несколько лет, HTML-подобный синтаксис, в виде JSX, стал последним писком моды. Любому веб-разработчику быстро надоест вручную писать теги в JS файлах. В таком случае, нам необходим инструмент, который сможет быстро и легко генерировать теги. [Emmet](https://emmet.io/) — очень полезный плагин, решающий данную задачу. Однако, иногда нам хочется чего-то более простого и лаконичного. Нам бы пригодилось расширение, которое будет добавлять закрывающий тег к его открытой паре, и автоматически изменять закрывающий тег, когда вы изменяете открывающий. Существует два расширения, которые могут справиться с поставленными задачами.
**Они также работают с JSX и множеством других языков (XML, PHP, Vue, JavaScript, TypeScript, TSX)**.
Вы можете найти их здесь — [Auto Close Tag](https://marketplace.visualstudio.com/items?itemName=formulahendry.auto-close-tag) и [Auto Rename Tag](https://marketplace.visualstudio.com/items?itemName=formulahendry.auto-rename-tag)
*Auto Rename Tag*
*Auto Close Tag*
**Похожие расширения:**
* [Auto Complete Tag](https://marketplace.visualstudio.com/items?itemName=formulahendry.auto-complete-tag) — объединяет возможности вышеуказанных плагинов;
* [Close HTML/XML tag](https://marketplace.visualstudio.com/items?itemName=Compulim.compulim-vscode-closetag).
GitLens
-------
Со слов автора, GitLens расширяет возможности Git, встроенного в Visual Studio Code. **Плагин включает удивительное количество функций, таких как указание автора, поиск коммитов, история и проводник**. Вы можете изучить полное описание этих возможностей [здесь](https://github.com/eamodio/vscode-gitlens). Если вы работаете с Git, то вы обязаны установить этот плагин.
*GitLens*
Существуют другие расширения, выполняющие специфические задачи. Если GitLens оказался для вас слишком объемным или вам не требуется большая часть его функций, то советую взглянуть на следующий список:
* [Git History](https://marketplace.visualstudio.com/items?itemName=donjayamanne.githistory) — отображает красивый граф истории коммитов. Рекомендуется.
* [Git Blame](https://marketplace.visualstudio.com/items?itemName=waderyan.gitblame) — позволяет увидеть информацию о текущей строке. Похожая функция встроена в GitLens.
* [Git Indicators](https://marketplace.visualstudio.com/items?itemName=lamartire.git-indicators) — позволяет увидеть изменения в файлах и количество добавленных и удаленных строк.
* [Open in GitHub / Bitbucket / GitLab / VisualStudio.com](https://marketplace.visualstudio.com/items?itemName=ziyasal.vscode-open-in-github) — дает возможность, одной командой, открыть репозиторий в браузере.
Git Project Manager
-------------------
[GPM](https://marketplace.visualstudio.com/items?itemName=felipecaputo.git-project-manager) позволяет открыть окно с новым репозиторием напрямую из редактора. **Проще говоря, вы можете открыть другой репозиторий не покидая VSCode**.
После установки данного расширения, пропишите `gitProjectManager.baseProjectsFolders` в список адресов, содержащих репозитории.
```
{
"gitProjectManager.baseProjectsFolders": [
"/home/user/nodeProjects",
"/home/user/personal/pocs"
]
}
```
**Похожие расширения:**
* [Project Manager](https://marketplace.visualstudio.com/items?itemName=alefragnani.project-manager) — лично не использовал, но он имеет более миллиона загрузок. Стоит попробовать.
Indenticator
------------
Визуально выделяет текущую глубину отступа. С этим [плагином](https://marketplace.visualstudio.com/items?itemName=SirTori.indenticator), вы легко различите блоки, расположенные на разных уровнях.
*Indenticator*
**Похожие расширения:**
* Guides.
VSCode Icons
------------
Новые иконки придадут редактору привлекательности!
*VSCode Icons*
**Похожие расширения:**
* [VSCode Great Icons](https://marketplace.visualstudio.com/items?itemName=emmanuelbeziat.vscode-great-icons);
* [Studio Icons](https://marketplace.visualstudio.com/items?itemName=jtlowe.vscode-icon-theme).
Dracula (Theme)
---------------
Полюбившийся мне [внешний вид](https://marketplace.visualstudio.com/items?itemName=dracula-theme.theme-dracula).
*Dracula theme*
**Другие плагины, которые могут вам пригодиться:**
* [Fira Code](https://github.com/tonsky/FiraCode) — моноширинный шрифт с лигатурами для программистов;
* [Live Server](https://marketplace.visualstudio.com/items?itemName=ritwickdey.LiveServer) — локальный сервер. Включает динамическоую перезагрузку для статических и динамических страниц;
* [Prettier for VSCode](https://github.com/prettier/prettier-vscode) — плагин для форматирования кода;
* [Settings Sync](https://marketplace.visualstudio.com/items?itemName=Shan.code-settings-sync) — позволяет сохранять пользовательские настройки, расширения и сочетания клавиш. Такая возможность позволит установить VSCode на другом устройстве в течении нескольких минут, и не потерять конфигурацию;
* [Multiple clipboards for VSCode](https://marketplace.visualstudio.com/items?itemName=slevesque.vscode-multiclip) — переопределяет стандартные команды «выделить» и «вырезать». Добавляет возможность скопировать несколько блоков текста в единый буфер.
Я поделился тем набором VSCode плагинов, которые регулярно использую. Какие расширения и темы, кроме указанных, используете вы? | https://habr.com/ru/post/354038/ | null | ru | null |
# Магия TestFlight, или Подробнее о технологиях Configuration Profile и URL Scheme
На Хабре уже были статьи про TestFlight (вот [тут](http://habrahabr.ru/post/133502/) и [тут](http://habrahabr.ru/post/133559/)), но в них речь шла главным образом про его использование и интеграцию/автоматизацию в процесс сборки. А мне всегда было интересно, как это работает изнутри:
• Как происходит сбор идентификаторов устройств? (Если вам непонятно, зачем собирать UDID’ы, пройдите по ссылкам выше)
• Как приложение устанавливается по переходу по ссылке?
• Как создается иконка на Home Screen?
• Все это хаки или легальные способы?
Если вы хотите построить свой TestFlight c блэк-джеком и всем остальным или просто интересуетесь, как сделано что-то из вышеперечисленного, – прошу под кат.
Предполагается, что читатель уже знаком с сервисом TestFlight и болью iOS-разработчиков – необходимостью собирать идентификаторы iOS-устройств. Testflight позволяет получить UDID очень просто – установкой Configuration Profile.
Профайл – это обыкновенный xml-файл, который благодаря разрешению “.mobileconfig” и оговоренному в документации Apple формату обрабатывается как руководство к действию, то есть интерпретируется операционной системой как описание настроек, которые нужно применить. Основное предназначение технологии – автоматическая настройка большого количества iOS-устройств, используется в основном в корпоративной среде.
Configuration Profile может содержать различные блоки, которые называются Payloads; каждый блок – это некая функциональность. С помощью Configuration Profile можно:
• Устанавливать политики запароливания
• Запретить использование устройств или сервисов
• Настроить сеть, VPN-доступ
• Настроить IMAP, Exchange, LDAP, CalDAV-аккаунты
• Создать иконки на Home Screen
• Установить сертификаты
Но как это все поможет получить UDID?
Существует специальный payload, который не устанавливает никакие настройки. Он называется Profile Service Payload и используется в многоступенчатом процессе включения iOS-устройств в корпоративные ряды (Over-The-Air Enrollment and Configuration). Для построения такой системы в полном объеме необходим сервер с поддержкой Simple
Certificate Enrollment Protocol (SCEP) – у Testflight и аналогичных сервисов используется именно такой. Для поддержки SCEP протокола существуют платные (от Microsoft) и бесплатные open source-решения, например [OpenSCEP](http://openscep.othello.ch).
Но, как оказалось, существует и более простой способ получения UDID устройства – реализовать только первый шаг из всего процесса принятия устройства в корпоративную среду. Этим шагом является запрос информации с устройства, так можно получить UDID, IMEI, ICCID, MAC адрес устройства, модель (например, iPad3,1 или iPhone4,1) и версию iOS. Для реализации только этого первого шага вполне достаточно обычного web-сервера.
Итак, ваш configuration profile может выглядеть примерно так:
```
xml version="1.0" encoding="UTF-8"?
PayloadContent
URL
http://SERVER\_URL/enroll.php
DeviceAttributes
UDID
IMEI
VERSION
PRODUCT
PayloadOrganization
parallels.com
PayloadDisplayName
Profile Service
PayloadVersion
1
PayloadUUID
...
```
При установке его пользователем информация об устройстве
будет отправлена по указанному SERVER\_URL методом POST. Если вы реализовываете взаимодействие по протоколу SCEP, а на присланную информацию нужно ответить
специальным SCEP Payload. Подробнее об этом можно почитать в [документации Apple](http://http://developer.apple.com/library/ios/#documentation/NetworkingInternet/Conceptual/iPhoneOTAConfiguration/Introduction/Introduction.html). Последним шагом в обмене профайлами и сертификами в случае с Testflight будет Configuration Profile с Web clips payload, благодаря которому на Home Screen iOS устройства появится ссылка на сервис.
И это, вообще говоря, единственный программный способ создания иконки на рабочем столе.
В случае, если вы имеете дело с корпоративной инфраструктурой, в последнюю очередь на устройство присылается configuration profile со всеми настройками. Этот профайл устанавливается сам, без каких-либо дополнительных вопросов пользователю.
Если ваш путь – не реализовывать SCEP на сервере, то отвечать на полученную информацию с устройства не обязательно. Правда нужно иметь в виду, пользователь после установки профайла получит неприятное сообщение:
Такого развития событий можно избежать, установив в вашем скрипте-обработчике redirect, как подсказывают в одной из веток на форуме разработчиков Apple. И вот тут получение идентификационной информации с iOS устройств в общем-то можно считать законченным.
Теперь разберемся, как TestFlight устанавливает приложения.
Такое “письмо счастья” получает каждый ваш тестер после сборки новой версии приложения:
Кнопка Install вызывает переход по ссылке вида:
`itms-services://?action=download-manifest&url=http://url/app-manifest.plist`
• “itms-services” означает использование Custom URL Scheme – технологии, которая позволяет приложениям взаимодействовать – вызывать одно из другого с передачей параметров запуска. Какое приложение обрабатывает именно такие ссылки непонятно, про похожие ссылки известно: “itms” – обрабатывается iTunes, “itms-books” – iBooks, “itms-apps” – App Store. С большой вероятностью, это специальное системное приложение, которое отвечает за установку приложений. Но не только системные приложения могут иметь custom URL, любое приложение может зарегистрировать свой собственный, указав его в Info.plist. Узнать URL интересного вам приложения и сообщить URL своего приложения общественности можно через специальный сервис handleopenurl.com.
• “url=http://url/app-manifest.plist” указывает на манифест, который хранит минимальный набор данных о приложении: название, категория и указания, где скачать бинарник приложения и его иконку. Такой манифест может сделать с помощью Xcode, если выбрать тип распространения “enterprise”.
• “action=download-manifest” – действие, которое должно быть выполнено вызванным приложением и, очевидно, означающее, что манифест описанный выше нужно скачать.
Как вы можете видеть, особых сложностей в реализации системы, подобной Testflight, нет, но мы в Parallels продолжаем использовать это готовое решение, так как серьезных причин для реализации внутреннего сервиса пока не видим.
Статья подготовлена по мотивам выступления на Yandex Mobile Camp Spb. | https://habr.com/ru/post/150094/ | null | ru | null |
# Авторизация с помощью Facebook и Vkontakte в одностраничном приложении на Backbonejs + Express
Привет Хабр! В данной статье я хочу рассказать о том, как реализовать авторизацию с помощью социальных сетей в одностраничном приложении на примере Backbonejs + Express.
Если у вас не установлен Node.js, вы можете скачать его с [офф.сайта](https://nodejs.org/en/). Для установки Express воспользуемся генератором приложений Express.
```
npm install express-generator -g
express habr
cd habr && npm install
```
Мы создали новое приложение Express с именем habr. Удалим каталог views, так как он нам не понадобится, переименуем images в img, javascripts в js, stylesheets в style и добавим папку public/tpl в которой будут лежать шаблоны. Теперь структура нашего проекта выглядит так:
```
.
├── app.js
├── bin
│ └── www
├── package.json
├── public
│ ├── img
│ ├── js
│ ├── tpl
│ └── style
│ └── style.css
├── routes
│ ├── index.js
│ └── users.js
```
Для загрузки компонентов будем использовать [RequireJS](http://requirejs.org/) и [RequireJS/textjs](https://github.com/requirejs/text) для загрузки шаблонов. Инициализация приложения будет выполняться в файле init.js.
Добавим конфигурацию RequireJs.
**public/js/init.js:**
```
requirejs.config({
baseUrl: "js/",
paths: {
jquery: 'lib/jquery.min',
backbone: 'lib/backbone.min',
underscore: 'lib/underscore.min',
fb: 'https://connect.facebook.net/ru_RU/all', //Facebook api
vk: 'https://vk.com/js/api/openapi', //Vk API
text: 'lib/text',
tpl: '../tpl'
},
shim: {
'underscore': {
exports: '_'
},
'vk': {
exports: 'VK'
},
'fb': {
exports: 'FB'
},
'backbone': {
deps: ['underscore', 'jquery'],
exports: 'Backbone'
}
}
});
```
Я сразу добавил библиотеки для работы с Vk и Facebook API.
Backbonejs не имеет функционала для вызова Middleware перед роутом, поэтому, воспользовавшись [примером](http://danialk.github.io/blog/2013/06/08/backbone-tips-after-and-before-methods-for-router/), я добавил 2 метода: before и after, которые будут вызываться перед и после каждого роута. Это нужно нам для проверки авторизации перед вызовом роутов к которым неавторизированый пользователь не должен получить доступ.
**public/js/baseRouter.js:**
**baseRouter.js**
```
define([
'underscore',
'backbone'
], function(_, Backbone){
var BaseRouter = Backbone.Router.extend({
before: function(){},
after: function(){},
route : function(route, name, callback){
if (!_.isRegExp(route)) route = this._routeToRegExp(route);
if (_.isFunction(name)) {
callback = name;
name = '';
}
if (!callback) callback = this[name];
var router = this;
Backbone.history.route(route, function(fragment) {
var args = router._extractParameters(route, fragment);
var next = function(){
callback && callback.apply(router, args);
router.trigger.apply(router, ['route:' + name].concat(args));
router.trigger('route', name, args);
Backbone.history.trigger('route', router, name, args);
router.after.apply(router, args);
}
router.before.apply(router, [args, next]);
});
return this;
}
});
return BaseRouter;
});
```
Теперь определим наши маршруты:
**public/js/router.js:**
```
define([
'baseRouter',
], function(BaseRouter){
return BaseRouter.extend({
routes: {
"secure": "secure",
"login" : "login"
},
//Маршруты к которым будет запрещен доступ неавторизированым пользователям
secure_pages: [
'#secure'
],
before : function(params, next){
next();
},
secure: function(){
console.log('This is secure page');
},
login: function(){
console.log('This is login page');
}
});
});
```
Создадим файл public/tpl/index.html, подключим bootstrap.css что бы он имел приемлемый вид:
```
* [Home](#)
* [Secure](#secure)
* Вы вошли как Гость
* [Login](#login)
```
Исправим файл app.js. Я удалил не нужный для моего примера код что бы не нагромождать файл лишним функционалом. Теперь app.js выглядит так:
**app.js**
```
var express = require('express');
var path = require('path');
var favicon = require('serve-favicon');
var logger = require('morgan');
var cookieParser = require('cookie-parser');
var bodyParser = require('body-parser');
var app = express();
app.use(logger('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(cookieParser());
app.use(express.static(path.join(__dirname, 'public')));
//Routes
app.get('/', function(req, res, next) {
res.sendFile(path.join(__dirname, 'public/tpl/index.html'));
});
// catch 404 and forward to error handler
app.use(function(req, res, next) {
var err = new Error('Not Found');
err.status = 404;
next(err);
});
// development error handler
if (app.get('env') === 'development') {
app.use(function(err, req, res, next) {
res.status(err.status || 500);
res.json({ message: err.message, error: err });
});
}
// production error handler
app.use(function(err, req, res, next) {
res.status(err.status || 500);
res.json({ message: err.message, error: err });
});
module.exports = app;
```
И добавим загрузку приложения в init.js:
```
require([
'backbone',
'router',
], function(Backbone, Route){
//Стартуем приложение после загрузки модели пользователя
var appRoute = new Route();
Backbone.history.start();
});
```
Запускаем наше приложение, и смотрим что получилось. Создадим [view](http://backbonejs.ru/#View) для нашей страницы логина.
**public/js/login\_view.js**
```
define([
'backbone',
'text!tpl/login.html', //Шаблон формы авторизации
'vk', //Vk Api
'fb' //Fb Api
], function(Backbone, Tpl, VK, FB){
return Backbone.View.extend({
initialize: function () {
this.render();
},
events: {
'click #fb_login' : 'fb_login',
'click #vk_login' : 'vk_login'
},
fb_login: function(e){
e.preventDefault();
},
vk_login: function(e){
e.preventDefault();
},
render: function(){
this.$el.html(Tpl);
}
});
});
```
Добавим шаблон для страницы логина:
```
### Login
Войти с помощью Facebook
Войти с помощью Vkontakte
``` | https://habr.com/ru/post/310594/ | null | ru | null |
# QScintilla: пишем свой лексер
Привет, хабр!
**UPD**: [третья](http://habrahabr.ru/post/144855/) часть цикла.
Это вторая статья цикла про QScintilla. Первая [здесь](http://habrahabr.ru/post/144411/). **Для начала хочу сказать огромное спасибо всем, кто вывел меня из кармоямы!** А теперь можно начать. Что мы сегодня будем делать? Мы напишем лексер для Assembler'а! «В коробке» его нету — не беда, напишем сами! Процесс довольно длительный, поэтому я буду немного меньше расписывать и комментировать. Тем более я не знаю язык ассемблера, так что лексер будет до ужаса примитивный и будет разрисовывать только команды и комментарии.
Как сказал Гагарин — «Поехали!»
На данном этапе, я полагаю, что вы уже прочитали первую статью (смотрите выше) и знаете как создать редактор и его кастомить. Продолжаем с того же проекта, который мы редактировали прошлый раз и с тем же набором инструментов (тут и поймались те, кто не читал первую статью).
Задача и идеи
-------------
Написать расцветку синтаксиса языка Assembler'а. Но лексера (схемы расцветки) в QScintilla по умолчанию нету. Ничего, напишем. Для этого есть класс QsciLexerCustom (по-секрету: у него есть виртуальные методы).
Заготовка
---------
Давайте заготовим ~~тесто~~ наш лексер. Заготовка выглядит так:
```
class QsciLexerASM : public QsciLexerCustom
{
Q_OBJECT
public:
explicit QsciLexerASM(QObject *parent = 0);
~QsciLexerASM();
//! Разбор текста на стили (самая важная функция)
void styleText(int start, int end);
//! Наши функции расцветки (вызывается из styleText())
void paintKeywords(const QString &source, int start);
void paintComments(const QString &source, int start);
//! Название языка (в нашем случае ASM
const char * language() const;
//! Цвета для стилей
QColor defaultColor(int style) const;
//! Описание стиля
QString description(int style) const;
//! Список стилей
enum {
Default = 0,
Comment = 1,
Keyword = 2
};
private:
QsciLexerASM(const QsciLexerASM &);
QsciLexerASM &operator=(const QsciLexerASM &);
QStringList keywordsList;
};
```
Некоторые перечисленные тут функции нужны не нам, а QScintilla. Но если они кому-то нужны, значит реализуем их в mainwindow.h:
```
QString QsciLexerASM::description(int style) const
{
switch(style) {
case Default:
return "Default";
case Comment:
return "Comment";
case Keyword:
return "Keyword";
}
return QString(style);
}
const char * QsciLexerASM::language()
{
return "ASM";
}
```
Я думаю, тут все понятно. Пойдем дальше. Теперь надо реализовать дефолтный цвет раскраски для всех стилей:
```
QColor QsciLexerASM::defaultColor(int style) const
{
switch(style) {
case Comment:
return Qt::darkGreen;
case Keyword:
return Qt::blue;
}
return Qt::black;
}
```
А вот только теперь мы будем раскрашивать наш код. Для этого нам надо знать какие есть в ассемблере ключевые слова. В [википедии](http://ru.wikipedia.org/wiki/%D0%AF%D0%B7%D1%8B%D0%BA_%D0%B0%D1%81%D1%81%D0%B5%D0%BC%D0%B1%D0%BB%D0%B5%D1%80%D0%B0#.D0.9D.D0.B0.D0.B1.D0.BE.D1.80_.D0.BA.D0.BE.D0.BC.D0.B0.D0.BD.D0.B4) я нашел немного. Для этого зададим наш keywordsList в конструкторе:
```
QsciLexerASM::QsciLexerASM(QObject *parent) :
QsciLexerCustom(parent)
{
keywordsList << "mov" << "add" << "sub" << "imul" <<
"or" << "and" << "xor" << "shr" <<
"jmp" << "loop" << "ret" << "int";
}
```
Продолжим. Теперь надо быть очень аккуратным — мы пришли к месту где мы будем раскрашивать синтаксис! Я приведу листинг кода функции styleText(), а потом его коротко докомментирую:
```
void QsciLexerASM::styleText(int start, int end)
{
if(!editor())
return;
// получим кусок сорца который нам надо разукрасить
char * data = new char[end - start + 1];
// обращение к Scintilla
editor()->SendScintilla(QsciScintilla::SCI_GETTEXTRANGE, start, end, data);
QString source(data);
delete [] data;
if(source.isEmpty())
return;
// Начнем разрисовывать!
paintKeywords(source, start);
paintComments(source, start);
}
```
Один момент. Две последние строчки метода. Функции paintKeyword() и paintComments() занимаются расцветкой ключевых слов и комментариев соответственно. Мы вызываем разукраску команд, а только потом комментариев. Почему? Догадайтесь.
Теперь все хорошо. Почти все методы реализованы. Осталось только реализовать paintKeyword() и paintComments():
```
void QsciLexerASM::paintKeywords(const QString &source, int start)
{
foreach(QString word, keywordsList) { // перебираем ключевые слова
if(source.contains(word)) {
int p = source.count(word); // считаем вхождения
int index = 0; // начнем считать индексы c 0
while(p != 0) {
int begin = source.indexOf(word, index); // считаем индекс вхождения
index = begin+1; // задаем точку отсчета для следущей итерации
startStyling(start + begin); // начнем стилизировать с индекса вхождения
setStyling(word.length(), Keyword); // для длины word.length задаем стиль Keyword
startStyling(start + begin); // заканчиваем стилизацию
p--;
}
}
}
}
void QsciLexerASM::paintComments(const QString &source, int start)
{
int p = source.count(";"); // посчитаем вхождения знака комментария
if(p == 0)
return;
int index = 0; // начнем считать индексы ";" с 0
while(p != 0) {
int begin = source.indexOf(";", index); // считаем индекс вхождения
int length=0; // длина комментария
index = begin+1; // задаем точку отсчета для следущей итерации
for(int k = begin; source[k] != '\n'; k++) // ведь source необязательно одна строка
length++;
startStyling(start + begin); // начнем стилизировать с индекса вхождения
setStyling(length, Comment); // для длины length задаем стиль Comment
startStyling(start + begin); // заканчиваем стилизацию
p--;
}
}
```
Готово. Теперь наш лексер умеет что-то делать. Можно компилировать. Да, можно. Да, определенно можно компилировать.
Результат
---------
С ассемблером я не работал. Поэтому дико извиняюсь. Не знаю даже базовые принципы работы с ним. Но я посчитал, что он отлично подходит как пример к этой статье.
Вот что у нас получилось:
[](http://dl.dropbox.com/u/7131620/Habr/lexer/program.png)
Видно некоторые баги, например в слове «dword» подсвечивается вхождение «or» как ключевое. Как подсказал товарищ [TheHorse](http://habrahabr.ru/users/thehorse/) — нужно проверять, что вхождение ключевых слов в тексте, разделено сепараторами. Но к концу написания статьи я так устал, что решил не фиксить этот баг, а оставить его фикс на читателей:)
А вот и наше творение: [qscintilla-demo-2](http://dl.dropbox.com/u/7131620/Habr/qsci/qscintilla-demo-2.tar.gz)
Спасибо, и еще раз извиняюсь за выбор языка. | https://habr.com/ru/post/144714/ | null | ru | null |
# Передаём файл между изолированными виртуальными машинами через побочные каналы
В интернете кто-то неправ
-------------------------
Не далее пяти дней назад на хабре появилась новость под заголовком "[В Apple M1 нашли уязвимость M1RACLES — возможна быстрая скрытая передача данных между приложениями](https://habr.com/ru/news/t/559514/)". В одном предложении суть формулируется так: в Apple M1 нашли регистр, который кто угодно может читать и писать из непривилегированного режима. Значит, это можно использовать для обмена данными в обход механизмов межпроцессного взаимодействия, предоставленных ОС. Однако, сам автор эту особенность значимой уязвимостью не считает, о чём пишет в разъяснительном комментарии:
> *So what's the point of this website?
> Poking fun at how ridiculous infosec clickbait vulnerability reporting has become lately. Just because it has a flashy website or it makes the news doesn't mean you need to care.
>
> If you've read all the way to here, congratulations! You're one of the rare people who doesn't just retweet based on the page title :-)
>
> But how are journalists supposed to know which bugs are bad and which bugs aren't?
> Talk to people. In particular, talk to people other than the people who discovered the bug. The latter may or may not be honest about the real impact.
>
> If you hear the words “covert channel”… it's probably overhyped. Most of these come from paper mills who are endlessly recycling the same concept with approximately zero practical security impact. The titles are usually clickbait, and sometimes downright deceptive.*
>
>
В комментариях к этой публикации развязалась умеренно оживлённая дискуссия о статусе находки: всё-таки серьёзная уязвимость или пустяк? Наряду с [@SergeyMax](/users/sergeymax)и [@wataru](/users/wataru) я обратил внимание, что каналов скрытого обмена и так существует предостаточно просто потому, что исполняющая клиентский софт или виртуальные машины аппаратура является разделяемой средой, грамотная модуляция состояний которой делает возможным произвольный обмен данными вне зависимости от инвариантов нижележащей ОС или гипервизора. Противоположной точки зрения придерживаются почтенные господа [@creker](/users/creker) и [@adjachenko](/users/adjachenko), утверждая, что доселе известные побочные каналы *качественно* уступают возможностям M1RACLES.
Эта заметка является наглядной иллюстрацией к моему утверждению о легкодоступности скрытых каналов обмена. Я собрал простой PoC из ~500 строк на C++, при помощи которого был успешно отправлен файл из одной виртуальной машины в другую на том же физическом хосте. Далее я кратко описываю его устройство, пределы применимости, и привожу выводы и мнение самого автора M1RACLES в конце.
Я не являюсь специалистом по информационной безопасности, поэтому чрезмерно полагаться на мои собственные выводы в конце статьи не следует.
Передача
--------
Повторю ключевой тезис для прозрачности: в общем случае, полная информационная изоляция исполняемых на едином аппаратном узле сред невозможна, потому что общая среда исполнения является разделяемым ресурсом, модуляция состояний которого может использоваться для построения каналов обмена данными. Гипервизоры, MMU, ОС, и прочие информационные барьеры могут лишь *затруднить* скрытый обмен данными, но не предотвратить его.
В случае M1RACLES, Apple случайно положила подходящий аппаратный ресурс на самое видное место. В других платформах общих регистров может не быть, но остаются другие средства. Сегодня мы сфокусируемся на вычислительных ресурсах процессора; любознательный читатель может в качестве факультатива слегка модифицировать код PoC, чтобы вместо процессорного времени модуляции подвергались, скажем, температура видеокарты, задержка доступа к файловой системе или RAM (забиванием кэша), и т.п.
Известная теория обработки сигналов предлагает [метод кодовой модуляции](https://ru.wikipedia.org/wiki/CDMA), широко применяемый для широкополосной передачи через зашумлённую среду. Кодовая модуляция позволяет получателю вытянуть полезный сигнал из-под шумовой полки, если известна кодирующая последовательность; для остальных же наблюдателей (включая приёмники с другой кодирующей последовательностью) сигнал будет выглядеть как шум. Единая среда может поддерживать теоретически неограниченное количество передатчиков с разными кодирующими последовательностями при условии их достаточного различия.
Автор: Ivajkin Timofej (translated from the english wiki) - en.wikipedia.org, CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=15444663Мы будем передавать высокие уровни кодирующего сигнала повышая нагрузку на процессор, и наоборот:
```
void drivePHY(const bool level, const std::chrono::nanoseconds duration)
{
static auto deadline = std::chrono::steady_clock::now();
deadline += duration; // Используем абсолютное время для предотвращения дрейфа фазы сигнала
if (level) // Передаём высокий уровень высокой нагрузкой
{
std::atomic finish = false;
const auto loop = [&finish]() {
while (!finish) { }
};
static const auto thread\_count = std::max(1, std::thread::hardware\_concurrency());
std::vector pool;
for (auto i = 0U; i < (thread\_count - 1); i++)
{
pool.emplace\_back(loop);
}
while (std::chrono::steady\_clock::now() < deadline) { }
finish = true;
for (auto& t : pool)
{
t.join();
}
}
else // Низкий уровень -- низкой нагрузкой
{
std::this\_thread::sleep\_for(deadline - std::chrono::steady\_clock::now());
}
}
```
В примере мы нагружаем все ядра, что весьма расточительно. Можно нагружать лишь одно ядро, если ОС предоставляет API для задания CPU core affinity (macOS, насколько мне известно, не предоставляет), но это создаст трудности в преодолении барьеров виртуализации, потому что одно ядро внутри гипервизора может отображаться на другое физическое ядро хоста. Однако, если API для affinity есть, и нет нужды пробрасывать канал передачи между изолированными виртуальными средами, можно сделать так:
```
#include // -lpthread
cpu\_set\_t cpuset{};
CPU\_ZERO(&cpuset);
CPU\_SET(0, &cpuset);
pthread\_setaffinity\_np(pthread\_self(), sizeof(cpu\_set\_t), &cpuset);
```
Как уже сказано, один бит передаётся прямым или инверсным кодом:
```
constexpr std::chrono::nanoseconds ChipPeriod{16'000'000}; // ок. 1...100 мс
std::bitset CDMACode("..."); // код пропущен
void emitBit(const bool value)
{
for (auto i = 0U; i < CDMACode.size(); i++)
{
const bool bit = value ^ !CDMACode[i];
drivePHY(bit, ChipPeriod);
}
}
```
Пакеты будем разделять девятью (или больше) нулевыми битами, а перед байтом данных будем отправлять один высокий бит, чтобы отличать его от разделителя пакетов (здесь есть простор для оптимизации):
```
void emitByte(const std::uint8_t data)
{
emitBit(1); // Стартовый бит
auto i = 8U; // Старший бит идёт первым
while (i --> 0)
{
emitBit((static_cast(data) & (1ULL << i)) != 0U);
}
}
void emitFrameDelimiter()
{
for (auto i = 0U; i < 20; i++) // не менее 9 нулевых битов
{
emitBit(0);
}
}
```
Для обнаружения ошибок в конце каждого пакета добавим два байта обыкновенной CRC-16-CCITT:
```
void emitPacket(const std::vector& data)
{
emitFrameDelimiter();
std::uint16\_t crc = CRCInitial;
for (auto v : data)
{
emitByte(v);
crc = crcAdd(crc, v);
}
emitByte(static\_cast(crc >> 8U));
emitByte(static\_cast(crc >> 0U));
emitFrameDelimiter();
}
```
Здесь у кого-то может возникнуть идея использовать традиционные коды Хэмминга для коррекции ошибок передачи, но у нас будет возможность разменивать пропускную способность канала на вероятность корректной передачи подстройкой длины кодирующей последовательности — сам метод кодового разделения уже предоставляет средства коррекции ошибок на битовом уровне.
Приём
-----
Если сигнал передаётся модуляцией нагрузки процессора, то на принимающей стороне мы можем оценить состояние среды передачи измеряя скорость каких-либо вычислений в быстром цикле. Например, можно инкрементировать счётчики. Создаваемые передатчиком флуктуации доступного процессорного времени затем извлекаются фильтром высоких частот, давая на выходе (сильно зашумлённый) сигнал:
```
bool readPHY()
{
static auto deadline = std::chrono::steady_clock::now(); // См. заметку о дрейфе фазы
deadline += SampleDuration;
const auto started_at = std::chrono::steady_clock::now();
std::vector counters;
const auto loop = [&counters](std::uint32\_t index) {
auto& cnt = counters.at(index);
while (std::chrono::steady\_clock::now() < deadline)
{
cnt++;
}
};
static const auto thread\_count = std::max(1, std::thread::hardware\_concurrency());
if (thread\_count > 1)
{
counters.resize(thread\_count, 0);
std::vector pool;
for (auto i = 0U; i < thread\_count; i++)
{
pool.emplace\_back(loop, i);
}
for (auto& t : pool)
{
t.join();
}
}
else
{
counters.push\_back(0);
loop(0);
}
const double elapsed\_ns =
std::chrono::duration\_cast(std::chrono::steady\_clock::now() - started\_at).count();
const double rate = double(std::accumulate(std::begin(counters), std::end(counters), 0)) / elapsed\_ns;
static double rate\_average = rate;
rate\_average += (rate - rate\_average) / PHYAveragingFactor;
return rate < rate\_average; // Просадка производительности если передатчик нагрузил ЦП
}
```
Обратите внимание, что конкретно эта реализация загружает все ядра процессора работой, что, конечно, чрезвычайно расточительно. Для передачи данных в пределах одной ОС (т.е., не пересекая границы виртуализированных сред) можно ограничиться одним ядром, как уже было показано выше.
Снова хочу отметить, что вместо модуляции загрузки ЦП можно управлять чем угодно ещё. Например, можно загружать диск или забивать кэш процессора холодными данными из памяти. Единственное требование заключается в получении на выходе (зашумлённого) двоичного сигнала, который можно семплировать с достаточно высокой фиксированной частотой.
Полученный зашумлённый сигнал с удалённым постоянным смещением мы направляем в CDMA коррелятор, как я изобразил на схеме:
Принципиальная схема приёмного трактаКоррелятор направляет полученную последовательность выборок состояния среды передачи в массив *каналов*. Каждый канал имеет общую кодирующую последовательность, но смещение в пределах последовательности у каждого канала своё. Каждая полученная выборка сравнивается с кодирующей последовательностью канала; затем, в конце периода последовательности подсчитывается количество совпадений, которое определяется шумом в канале передачи и фазовым сдвигом относительно кодирующей последовательности передатчика. Итоговый сигнал извлекается взвешенным суммированием выхода каждого канала, где вес определяется корреляцией локальной кодирующей последовательности канала с полученным сигналом.
Аналогичным образом извлекается информация о фазе сигнала: на выходе каждого канала мы имеем пилообразный сигнал, представляющий фазу кодирующей последовательности текущего канала. Подсчитанная аналогично предыдущему случаю взвешенная сумма представляет очищенный от шума тактирующий сигнал, на основании которого дальнейшая логика приёмного тракта защёлкивает принятые биты данных.
Практические системы здесь обычно включают фазовую автоподстройку частоты для синхронизации длительности периода кодирующей последовательности между передатчиком и приёмником. Мы этого делать не станем в угоду простоте реализации. Вместо этого, состояние среды передачи будет семплироваться с утроенной частотой; соответственно, количество каналов коррелятора будет равно длине кодирующей последовательности, умноженной на три.
Знакомый с обработкой сигналов в телекомах читатель сейчас понимающе позёвывает, ведь похожие принципы используются во многих распространённых приложениях, от GPS до сотовых сетей. Для сравнения, типичная архитектура приёмного тракта GPS приёмника выглядит примерно так (каналы **Q*x*** на схеме можно проигнорировать, поскольку [квадратурное разложение](https://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D0%BD%D1%84%D0%B0%D0%B7%D0%BD%D0%B0%D1%8F_%D0%B8_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D1%83%D1%80%D0%BD%D0%B0%D1%8F_%D1%81%D0%BE%D1%81%D1%82%D0%B0%D0%B2%D0%BB%D1%8F%D1%8E%D1%89%D0%B8%D0%B5_%D1%81%D0%B8%D0%B3%D0%BD%D0%B0%D0%BB%D0%B0) в нашей среде смысла не имеет):
Схема из "Principles of GNSS, inertial, and multisensor integrated navigation systems", P. D. Groves, 2-е изд.Использование достаточно длинной кодирующей последовательности позволяет установить канал связи с произвольно низкой вероятностью ошибок поверх произвольно зашумлённой среды. Впрочем, зависимость между скоростью и шумовым порогом, разумеется, является фундаментальной для телекомов вообще.
Прямое применение кодов Хэмминга здесь вряд ли оправданно, потому что условия, при которых могут возникать битовые инверсии сигнала, неизбежно приведут к искажениям тактового сигнала, из чего последуют пропуски либо спонтанное защёлкивание бит, что сделает коды Хэмминга неэффективными. Более совершенные методы коррекции ошибок вроде кодов Рида-Соломона или LDPC представляют интерес, но их реализация несколько выходит за рамки этого эксперимента ввиду сравнительно высокой сложности.
Полученные на выходе коррелятора биты декодируются в пакеты тривиальной логикой, зеркалирующей логику передатчика, что я привёл выше. Здесь её код я показывать не буду, вместо этого рекомендую сразу пройти на гитхаб и увидеть всё сразу:
[**https://github.com/pavel-kirienko/cpu-load-side-channel**](https://github.com/pavel-kirienko/cpu-load-side-channel)
Результат
---------
Процесс передачи файла с одной виртуалки на другую я записал на видео:
Условия здесь были далеки от идеальных, потому что в фоне на хосте виртуализации работал ffmpeg (записывающий это видео в 4K в реальном времени на процессоре), браузер с ~30 вкладками и музыкой, вечно голодная до ресурсов плазма с виджетами и обычный набор каждодневного софта на моей рабочей станции. Я привожу это в качестве дополнительной иллюстрации (очевидного) факта, что устойчивость канала к шуму является лишь вопросом минимальной скорости передачи.
Последняя может вызвать у читателя здравое недоумение: на видео, тактовый период кодирующей последовательности был равен 16 мс, и её длина 1023 бит, т.е., передача одного бита занимала примерно 16 секунд, давая скорость около 0.06 бит в секунду. Передача семибайтового файла с CRC и разделителями заняла почти полчаса. Много ли можно дел наворотить на такой-то скорости?
Если сравнивать с M1RACLES (скорость передачи более 8 Mb/s), то нет. Если сравнивать с популярным предположением по-умолчанию об информационной изоляции виртуализированных сред (скорость передачи 0 b/s), то да.
Преодоление барьеров виртуализации сильно зашумляет канал, что требует использования более длинной кодирующей последовательности. Также увеличивается временной джиттер, что требует и увеличения продолжительности тактового периода. Процессы же в пределах одной ОС могут коммуницировать на скорости **более одного бита в секунду**, в чем легко убедиться на практике, поменяв параметры `ChipPeriod` и `CDMACodeLength` в PoC (я экспериментировал на Manjaro с ядром 5.4 на Intel Core i7 990X @ 4 GHz).
Поддержание канала в текущей реализации требует постоянной полной загрузки процессора (или хотя бы одного его ядра) процессом-приёмником, что может стать серьёзным ограничением. Это, вероятно, можно обойти использованием более сложных схем модуляции, либо модуляцией состояний других системных ресурсов; например, загрузки диска или кэша процессора. Желающие поэкспериментировать приглашаются поделиться результатами.
Также было бы интересно поэкспериментировать с передачей за пределы изолированных систем (airgapped networks), о чём писал [Mordechai Guri](https://www.zdnet.com/article/academics-turn-ram-into-wifi-cards-to-steal-data-from-air-gapped-systems) и многие до него. Для этого можно подвергать модуляции шум системы охлаждения, температуру её выхлопа, ЭМИ, светодиоды на клавиатуре, и вообще всё, что имеет видимые внешние проявления.
Выводы
------
Я опубликовал [заметку в **/r/netsec**](https://www.reddit.com/r/netsec/comments/nokpa4/trivial_file_transfer_between_separate_vms/) об этом эксперименте, где в комментариях отметился Hector Martin, автор M1RACLES. Моя изначальная позиция была следующая: побочные каналы присутствуют всегда и в любой системе; M1RACLES лишь добавляет ещё один, а значит, это ничего кардинально не меняет. Если считать его уязвимостью, это делает любую систему в принципе уязвимой по-умолчанию, ведь побочные каналы устранить невозможно; значит, сам термин "уязвимость" применимо к компьютерным системам теряет информационную нагрузку.
Вероятно, сведущему в инфобезе человеку такой взгляд на вещи покажется наивным, я мало знаком с этой областью. Hector Martin скорректировал мои заблуждения, указав на то, что уязвимость как абсолютная метрика бессмысленна, всегда необходимо учитывать контекст. В этом смысле, наличие высокоскоростного канала скрытого обмена несколько расширяет множество реализуемых атак, следовательно, M1RACLES является вполне реальной уязвимостью, пусть и по-прежнему крайне малой значимости. Ниже релевантная часть его комментария для полноты:
> *We already know all systems are vulnerable to certain side-channel attacks. In particular, all systems with shared resources have side channels. Those side channels are easy to turn into covert channels, as you did. The bandwidth, and the severity, is proportional to how closely coupled the security domains are (as you found out, where the VM boundary reduces your performance). As the severity gets higher, you go from 1 bit per second covert channels, to megabytes per second covert channels, to actually being able to steal data from noncooperative entities (actual dangerous side channels) under increasingly less demanding circumstances.*
>
> *[...]*
>
> *So M1RACLES is interesting because it is not a side channel - so it poses no danger of leaking data from unwitting processes - but it is a highly efficient covert channel, which does matter under a very small but not nonexistent set of attack scenarios. Does it add covert channel capability where none existed prior? No. But that doesn't mean it's not a vulnerability; as I said, we don't qualify systems on some kind of absolute "vulnerable/not vulnerable" scale. We look at individual issues and then figure out how they affect the overall security of the system under certain attack scenarios.*
>
>
Заодно он жёстко раскритиковал работу Mordechai Guri, указав на околонулевую дельту его публикаций. Однако, это я не берусь комментировать, поскольку в инфобезе не ориентируюсь. Для меня это всё представляет интерес лишь в контексте технической реализации обработки сигналов, нежели значения для отрасли.
Финальные выводы я сделал следующие:
* ОС и гипервизоры не являются средствами информационной изоляции и не в состоянии предотвратить межпроцессный обмен данными.
* Однако, скрытый межпроцессный обмен серьёзной угрозой не является.
* M1RACLES количественно улучшает доселе существующие возможности скрытого обмена, но итоговый эффект остаётся незначительным.
 | https://habr.com/ru/post/560508/ | null | ru | null |
# Что такое -1.#IND и -1.#J?
Любой опытный программист знает, что стандарт представления значений с плавающей точкой ([IEEE 754](http://en.wikipedia.org/wiki/IEEE_754-1985)) оставляет несколько зарезервированных значений, соответствующих *не-числам* (NaN, not-a-number). Стандартная библиотека Visual C печатает не-числа следующим образом:
| Печатается | Означает |
| --- | --- |
| `1.#INF` | Положительная бесконечность |
| `-1.#INF` | Отрицательная бесконечность |
| `1.#SNAN` | Положительное сигнальное не-число *(signaling NaN)* |
| `-1.#SNAN` | Отрицательное сигнальное не-число *(signaling NaN)* |
| `1.#QNAN` | Положительное несигнальное не-число *(quiet NaN)* |
| `-1.#QNAN` | Отрицательное несигнальное не-число *(quiet NaN)* |
| `1.#IND` | Положительная неопределённость |
| `-1.#IND` | Отрицательная неопределённость |
Положительная и отрицательная бесконечности могут получаться при переполнении в результате арифметического действия — например, при делении на ноль, или при взятии логарифма от положительного нуля. (По стандарту IEEE, любое значение с плавающей точкой имеет определённый знак — не только не-числа существуют в положительном и отрицательном вариантах, но и нулей тоже два.)
Сигнальные и несигнальные не-числа, как правило, получаются не в результате вычислений, а генерируются программой намеренно — например, в C++ их можно получить, вызвав методы `signaling_NaN()` или `quiet_NaN()` класса `std::numeric_limits`. Скажем, воображаемая программа электронных таблиц могла бы использовать их для обозначения высокоуровневых ошибок при вычислении ячейки — «циклическая ссылка», «неизвестная функция» и т.п. Любая операция с использованием не-числа даёт в результате не-число, т.е. приложению достаточно проверить только окончательный результат вычисления, чтобы убедиться в корректности всех этапов.
Сигнальных и несигнальных не-чисел зарезервировано много, но runtime-библиотека Visual C при печати различает их только по знаку, и игнорирует присвоенное приложением значение. Исключениями являются две *неопределённости*, которые могут получаться при вычислении, не имеющем ни конечного, ни бесконечного результата: например, сумма `1.#INF` и `-1.#INF`, логарифм или квадратный корень отрицательного числа. В стандарте прописано, что неопределённость должна представляться несигнальным не-числом, но каким именно — не определено. В разных процессорах значения получаются разными, так что разработчикам стандартных библиотек приходится экспериментировать. В x86 неопределённость получается *отрицательным несигнальным не-числом* с нулевым значением, но в других процессорах неопределённость может оказаться положительной.
*(Прим. перев.: я не поленился и проверил, на x86 логарифм отрицательного нуля всё равно `-1.#INF`, как и у положительного — а не `-1.#IND`)*
Комментаторы Чена обратили внимание, что не-числа могут печататься и иначе.
Например, нижеследующий код напечатает `1.#J`:
```
double z = 0;
printf("%.2f", 1/z);
```
В результате деления на ноль получается `1.#INF`, и затем runtime-библиотека должна округлить это не-число *до двух знаков после запятой*. Вероятно, именно поэтому все не-числа начинаются с "`1.`" — чтобы при округлении можно было найти запятую, и отсчитывать от неё знаки. Отсчитываем два, получаем "`#I`", и следующая «цифра» — "`N`" — больше 5, так что мы **округляем** предыдущую «цифру» вверх до "`J`".
Графически это даже кажется понятным — что такое J, как не I, закруглённая вверх?
Вряд ли такая печать не-чисел была заложена в спецификации; но после того, как библиотека выпущена, менять алгоритм уже нельзя — одному богу известно, сколько существующих приложений полагаются на то, что получат именно `1.#J`.
С другой стороны Реймонд замечает, что *фонетическое* [округление (огубление) I давало бы Ü](http://ru.wikipedia.org/wiki/%D0%9E%D0%B3%D1%83%D0%B1%D0%BB%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9_%D0%B3%D0%BB%D0%B0%D1%81%D0%BD%D1%8B%D0%B9_%D0%BF%D0%B5%D1%80%D0%B5%D0%B4%D0%BD%D0%B5%D0%B3%D0%BE_%D1%80%D1%8F%D0%B4%D0%B0_%D0%B2%D0%B5%D1%80%D1%85%D0%BD%D0%B5%D0%B3%D0%BE_%D0%BF%D0%BE%D0%B4%D1%8A%D1%91%D0%BC%D0%B0). Вот если бы округление `1.#INF` до двух знаков печатало `1.#Ü`, это было бы über-гикство. | https://habr.com/ru/post/171203/ | null | ru | null |
# Частые ошибки при разработке lockfree-алгоритмов и их решения
На хабре уже было несколько статей про lock-free алгоритмы. Этот пост — это перевод статьи [моего коллеги](http://community.topcoder.com/tc?module=MemberProfile&cr=22777893), которую мы планируем публиковать в нашем корпоративном блоге. По роду деятельности мы пишем огромное количество lock-free алгоритмов и структур данных, и этой статьей хочется показать, насколько это интересно и сложно одновременно.
Эта статья во многом похожа на [эту статью](http://habrahabr.ru/post/141266/), но в той статье рассматриваются не все проблемы, с которыми можно столкнуться, разрабатывая lock-free структуры данных, и уделяется очень мало внимания решению этих проблем. В этой статье хочется детально остановиться на некоторых решениях, которые мы используем в реальной реализации lock-free структур данных в нашем продукте, и больше внимания уделить оценке производительности.
По определению, lock-free алгоритм гарантирует, что время между двумя подряд идущими завершенными операциями ограничено сверху некоторой величиной, которая не зависит от того, как операционная система эти потоки распределит во времени. Такая гарантия звучит очень приятно, потому что потоки могут обращаться к одному и тому же участку памяти одновременно, и даже если операционная система решит временно усыпить один или несколько потоков посреди выполнения какой-то операции с этим участком памяти, остальные потоки продолжат работу. Как бы два или более потока не пересеклись друг с другом во времени, хотя бы один из них всегда завершится за конечное время (в отличие от wait-free, lock-free не гарантирует, что все они завершатся за конечное время).
Lock-free алгоритмы обычно противопоставляются традиционному подходу к написанию многопоточных приложений с использованием блокировок вокруг кода, обращающегося к общим участкам памяти. Когда поток хочет обратиться к памяти, он блокирует к ней доступ других потоков. Если какой-то другой поток заблокировал доступ раньше, то текущий поток ждет, пока блокировка не будет снята. Если операционная система решит временно усыпить поток, владеющий блокировкой, вся система останавливается без возможности изменить общий участок памяти.
Вместо использования блокировок, lock-free алгоритмы используют команду, известную как compare and swap (CAS). Ее логику можно описать следующим фрагментом кода, с той оговркой, что CAS выполняется атомарно:
```
1 bool CompareAndSwap(Value* addr, Value oldVal, Value newVal){
2 if(*addr == oldVal){
3 *addr = newVal;
4 return true;
5 }else{
6 return false;
7 }
8 }
```
Основными проблемами lock-free алгоритмов являются следующие три:
1. Часто lock-free реализация является менее практичной, чем реализация с блокировками.
2. Писать lock-free код не просто.
3. Писать правильный lock-free код невероятно сложно.
Чтобы доказать пункт три, расмотрим простой пример — реализацию стека на связных списках. Если попросить человека, не знакомого с lock-free написать стек, то его первая реализация будет примерно следующей:
Для операции добавления в стек, создадим новый элемент связного списка, указатель на следующий элемент которого указывает на текущую вершину стека. Затем попытаемся с помощью CAS поменять вершину стека на новый элемент. Если CAS проходит успешно, элемент вставлен. Если CAS возвращается с ошибкой (что значит, что вершина стека изменилась между тем, как мы ее прочитали, и тем, как CAS выполнился), повторим все с начала.
Для операции удаления из стека, запомним текущую вершину стека, и, с помощью CAS, попытаемся поменять ее на значение ее указателя на следующий элемент. Если CAS прошел успешно, то элемент из стека убран, иначе вершина стека была изменена другим потоком, и мы пытаемся удалить ее опять.
На С++ это будет выглядить примерно следующим образом:
```
1 template
2 class LockFreeStack{
3 struct Node{
4 Entry\* entry;
5 Node\* next;
6 };
7
8 Node\* m\_head;
9
10 void Push(Entry\* e){
11 Node\* n = new Node;
12 n->entry = e;
13 do{
14 n->next = m\_head;
15 }while(!CompareAndSwap(&m\_head, n->next, n));
16 }
17
18 Entry\* Pop(){
19 Node\* old\_head;
20 Entry\* result;
21 do{
22 old\_head = m\_head;
23 if(old\_head == NULL){
24 return NULL;
25 }
26 }while(!CompareAndSwap(&m\_head, old\_head, old\_head->next));
27
28 result = old\_head->entry;
29 delete old\_head;
30 return result;
31 }
32 }
```
К сожалению, эта, кажущаяся на первый взгляд разумной, реализация lock-free стека содержит огромное количество ошибок.
##### SegFault
Даже самый простой тест такого стека быстро упадет с Segmentation Fault. Причина — в строке 22 мы читаем указатель на текущую вершину стека. В стоке 26 мы обращаемся к ее полю next. За время между тем, как мы прочитали указатель, и тем, как мы обратились к его полю next, одновременно выполняющийся Pop мог удалить этот элемент (строка 29), тем самым приведя к тому, что память, прочитанная в стоке 26, уже освобождена.
Для правильной работы алгоритма необходим какой-то безопасный алгоритм управления памятью.
##### Потеря элемента
Успешный CAS не гарантирует, что за время его выполнения память не была изменена. Он гарантирует, что ее значение в момент, когда он ее перезаписал, было равно тому значению, которое ему передано как ожидаемое. Иными словами, если вы вызываете CAS(ptr, 5, 6) в момент, когда значение в ptr равно пяти, затем другой поток меняет значение в ptr на семь, и затем обратно на пять, CAS выполнится успешно, перезависав пять шестью. Это может привести к проблеме, известной как проблема ABA. Рассмотрим следующий пример:
Допустим, что в стеке сейчас два элемента, A -> C.
**Поток 1** вызывает Pop, читает в строке 22 m\_head (A), в строке 26 читает old\_head->next (С), а затем операционная система усыпляет поток.
**Поток 2** вызывает Pop, и успешно убирает элемент A.
**Поток 2** вызывает Push, и успешно вставляет элемент B.
**Поток 2** вызывает Push опять, и вставляет элемент, расположенный по тому же адресу, что и A (либо A был освобожден, и затем другой элемент был заведен по тому же адресу, либо пользователь решил вставить элемент, который он только что взял со стека, обратно)
**Поток 1** просыпается, и вызывает CAS. CAS выполняется успешно, не смотря на то, что за это время m\_head изменился три раза! Как следствие, элемент B потерян.
##### Не lock-free
Стандарт С++ не гарантирует, что new и delete являются lock-free. В чем смысл разрабатывать lock-free алгоритм, если он вызывает библиотечные функции, которые не lock-free? Для того, чтобы алгоритм был lock-free, работа с памятью тоже должна быть lock-free.
##### Одновременный доступ к памяти
Если текущее значение в некоторой ячейке памяти равно 100, и один из потоков в данный момент пишет в нее 200, а другой поток читает ее значение (допустим, что кроме этих двух потоков в системе других потоков нет). Какое значение прочитает второй поток? Кажется разумным, что он прочитает либо 100, либо 200. Однако, это не так. В С++ описанный сценарий приводит к неопределенному поведению, и второй поток теоретически может прочитать 42. До C++11 люди использовали volatile для переменных, к которым был возможен одновременный доступ, но на самом деле volatile для этой цели [использован никогда быть не должен](http://software.intel.com/en-us/blogs/2007/11/30/volatile-almost-useless-for-multi-threaded-programming).
В нашей реализации Push и Pop оба читают и пишут m\_head, тем самым, каждое чтение m\_head приводит к неопределенному поведению, и может вернуть значение, которое никогда в m\_head записано не было.
##### Порядок обращений к памяти
Хорошо известно, что как компилятор, так и процессор могут поменять порядок выполнения команд. Рассмотрим такой пример. Пусть x и y оба равны нулю, и затем два потока выполняют следующий код:
Поток 1: print x; x = 1; print y;
Поток 2: print y; y = 1; print x;
Допустим, что оба потока вывели два нуля. Из этого следует, что первый поток вывел y до того, как второй поток присвоил ему единицу, что произошло перед тем, как второй поток вывел x, что произошло перед тем, как первый поток присвоил ему единицу, что произошло перед тем, как первый поток вывел y. То есть первый поток вывел y прежде, чем он вывел y, что не имеет смысла. Однако, такой сценарий возможен, потому что как компилятор, так и процессор могли поменять порядок чтения и записи x и y врутри потоков.
В нашей реализации lock-free стека мы можем видеть значение в указателе на следующий элемент, которое было давно изменено, и, как следствие, можем обратиться к памяти, которая была освобождена.
#### Так как же написать lock-free стек?
Большинство описанных проблем имеют более одного решения. Здесь приводятся решения, которые мы используем в нашей работе как для стека, так и для других структур данных.
##### SegFault
Прежде, чем удалить участок памяти, надо убедиться, что никто эту память не читает. Первая мысль, которая приходит на ум, это использовать счетчик ссылок, но это решение не работает: между тем, как мы получили адрес, и тем, как мы увеличили счетчик ссылок, память могла быть освобождена. Мы используем решение, которое называется «Hazard Pointers». В случае для стека, каждый поток имеет спецальный видимый всем указатель (назовем его «локальный указатель»), где хранится адрес элемента, с которым данный поток работает в настоящий момент. Прежде, чем удалить любой элемент, удаляющий поток убеждается, что этот элемент не содержится ни в одном из локальных указателей. Если он содержится в локальных указателях, удалять элемент нельзя. Можно либо подождать и попробовать снова, либо занести элемент в очередь на удаление и доверить другим потокам удалить его позже.
Каждый поток, который хочет сделать какую-либо операцию на вершине стека сначала сохраняет вершину стека в свой локальный указатель, затем убеждается, что сохраненный в локальный указатель элемент все еще является вершиной стека (он мог быть убран и память могла быть освобождена пока мы сохраняли его в локальный указатель). После этого поток может быть уверен, что память, занятая элементом, освобождена не будет.
Большим недостатком может являться то, что для удаления элемента требуется просканировать массив, размер которого равен количеству потоков в системе. Один из вариантов оптимизации может быть следующий: вместо удаления элемента всегда класть его в очередь, и только когда очередь набирает достаточно большое количество элементов на удаление (сравнимое с количеством потоков), удалить их все сразу. В этом случае можно скопировать значения всех локальных указателей на тот момент в какую-то структуру данных с быстрым поиском (например, хеш-таблицу), и использовать эту структуру данных, чтобы проверять, можно ли удалить элемент.
Для структур данных сложнее, чем стек (связные списки, skiplists) может потребоваться более одного локального указателя на поток.
##### Потеря элемента
Чтобы ABA проблема никогда не происходила, достаточно гарантировать, что m\_head никогда не примет одно и тоже значение дважды. Для этого можно хранить с указателем 64-ех битное число (назовем его версией), которое увеличивается на единицу с каждой операцией. Для того, чтобы менять указатель и версию одновременно, нам понадобится Double CAS, который доступен на всех современных процессорах.
##### Не lock-free
Чтобы решить проблему с заведением памяти, можно просто не заводить память. В нашем коде мы сохраняем указатель на следующий элемент прямо в структуре элемента. Но это не всегда является приемлемым решением, потому что расходуется 8 байт на каждый элемент, даже если элемент не находится в стеке.
##### Одновременный доступ к памяти
Мы используем boost::atomic для переменных, к которым возможен доступ из нескольких потоков. Хотя в компиляторе, который мы используем (g++ 4.6) уже есть реализация std::atomic, она значительно менее эффективна, чем boost::atomic, потому что использует memory\_barrier после каждой операции, даже если memory\_barrier после нее не нужен.
##### Порядок обращений к памяти
В С++11 была введена новая модель памяти и правила обращения к памяти для atomic переменных. Для каждой операции чтения или записи можно указать, какие гарантии требуются. Для обращений к вершине lock-free стека мы вынуждены использовать CompareAndSwap с гарантией sequential consistency (это самая строгая гарантия, и, как следствие, самая медленная). Sequential consistency значит, что для всех операций чтения и записи, выполненных в некоторый промежуток времени всеми потоками, существует порядок такой, что каждый поток видел эти операции, как если бы они произошли в этом порядке.
Если вы понимаете модель памяти С++11, и попытаетесь проанилизировать, какие гарантии следует использовать для работы с локальными указателями (hazard pointers), вы можете предположить, что aqcuire/release достаточны.
**Что такое acquire/release**Гарантия acquire/release может быть описана следующим сценарием: если Поток 1 поменял переменную A с гарантией release, а затем переменную B с гарантией release, а Поток 2 прочитал B с гаранией acquire, и увидел значение, записанное Потоком 1, то гарантируется, что если затем Поток 2 прочитает A с гарантией acquire, то он увидит изменение, сделанное Потоком 1.
Мы использовали acquire/release некоторое время, пока в один день сервер не упал на удачно поставленном assert. Детальный анализ ошибки показал, что при использовании acquire/release возможен следующий сценарий:
**Поток 1** готовится выполнить Pop и читает вершину стека
**Поток 1** пишет вершину стека в свой локальный указатель (используя release гарантию)
**Поток 1** читает вершину стека снова, она не изменилась
**Поток 2** убирает вершину стека, и решает ее удалить (или добавляет в очередь на удаление, и другой поток решает ее удалить — назовем поток, удаляющий элемент, **Поток 3**)
**Поток 3** читает массив локальных указателей с гарантией acquire. Здесь возникает пробоема — не гарантируется, что мы видим изменение, сделанное **Потоком 1**.
**Поток 3** удаляет память.
**Поток 1** разыменовывает сохраненную вершину стека, которая была удалена, и падает с SegFault.
Если же использовать Sequential Consistency как для доступа к локальным указателям, так и для работы с вершиной стека, такой сценарий не возможен. Поскольку порядок операций для всех потоков одинаков, то либо **Поток 2** убрал элемент с вершины стека прежде, чем **Поток 1** проверил его после записи в локальный указатель (тогда **Поток 1** поймет, что вершина стека изменилась, и начнет сначала), либо **Поток 1** успешно сравнил свой локальный указатель с вершиной стека прежде, чем **Поток 2** убрал элемент с вершины стека, что значит, что **Поток 3** увидит удаляемую вершину стека в локальном указателе.
#### Производительность
Для этой статьи мы написали две реализации стека: одну lock-free, другую — с использованием std::mutex. Тестовая программа запускала несколько потоков, и вызывала Push и Pop с равной вероятностью в бесконечном цикле. Для замеров использовался Dell Precision T5500. Результаты показаны на графике ниже. Ось X — количество потоков, ось Y — количество операций в секунду.
Выглядит не очень впечатляюще.
Одна из проблем заключается в том, что по своей природе стек имеет очень узкое место — его вершину. Все потоки сражаются за то, чтобы изменить ее первыми, и производительность будет настолько высока, насколько быстро есть теоретическая возможность менять вершину. Операции Push и Pop настолько просты, что даже при использовании одного потока упираются в лимит количества изменений вершины стека в единицу времени. Добавление новых потоков только замедляет общую производительность, потому что теперь надо синхронизировать изменения вершины стека между потоками.
Другая проблема заключается в том, что когда несколько потоков одновременно пытаются поменять вершину стека, только один из них это успешно сделает, и все остальные потоки пойдут на новую итерацию. Это проблема. Как известно, у каждой проблемы есть быстрое, красивое но неправильное решение. Таким решением для этой проблемы будет добавить usleep(250) после неудачного CAS. Это простой, но не оптимальный способ заставить потоки меньше пересекаться при изменении вершины стека. Результат может показаться удивительным — добавление usleep(250) улучшает производительность в 10 раз! На практике мы используем немного более сложные подходы для уменьшения количества неудачных CAS, но как видно, даже такой простой подход, как usleep, дает отличные результаты.
Интересно также посмотреть на то, сколько ресурсов потребляют различные реализации:
Вот так выглядит HTOP для запуска с lock-free стеком без usleep в 16 потоках:
Как видно, процессор занят на 100%. Это связано с тем, что все потоки в цикле пытаются изменить вершину стека, снова и снова выполняя новую итерацию, целиком потребляя доступное им процессорное время.
Вот так выглядит HTOP для запуска с lock-free стеком с usleep в 16 потоках:
Процессор почти простаивает. Потоки, не сумевшие сразу поменять вершину, спят, не занимая процессор. Это удивительное наблюдение — добавление usleep не только увеличило полезную производительность в 10 раз, но и заметно понизило потребление процессорного времени.
Вот так выглядит HTOP для запуска со стеком с блокировками в 16 потоках:
Здесь хорошо видно, что процессор целиком занят системными вызовами. Иными словами, почти все процессорное время затрачено на работу с блокировками.
#### Заключение
Lock-free гарантирует, что система всегда будет выполнять полезную работу, даже если часть потоков была приостановлена операционной системой. Но lock-free не гарантирует, что это будет достигнуто эффективно. Кроме того, lock-free алгоритмы часто содержат ошибки, которые не всегда легко заметить или воспроизвести. Простая реализация стека в начале этой статьи содержала пять различных ошибок, и по производительности уступала реализации с блокировками. Если вы хотите использовать lock-free алгоритмы, убедитесь, что они того стоят, как с точки зрения производительности, так и с точки зрения сложности реализации. Старайтесь не изобретать свои собственные lock-free алгоритмы, а находить готовые реализации или научные работы.
#### Код
**Исходный код**С блокировками:
```
1 #include
2 #include
3
4 template
5 class LockedStack{
6 public:
7 void Push(T\* entry){
8 std::lock\_guard lock(m\_mutex);
9 m\_stack.push(entry);
10 }
11
12 // For compatability with the LockFreeStack interface,
13 // add an unused int parameter.
14 //
15 T\* Pop(int){
16 std::lock\_guard lock(m\_mutex);
17 if(m\_stack.empty()){
18 return nullptr;
19 }
20 T\* ret = m\_stack.top();
21 m\_stack.pop();
22 return ret;
23 }
24
25 private:
26 std::stack m\_stack;
27 std::mutex m\_mutex;
28 };
```
Без блокировок (в коде отсутствует логика, отвечающая за очистку памяти)
```
1 class LockFreeStack{
2 public:
3 // Элементы стека должны наследоваться от Node
4 //
5 struct Node{
6 boost::atomic next;
7 };
8
9
10 // К сожалению, нет платформо-независимого способа написать этот класс.
11 // Приведенный код работает для gcc на архитектуре x86\_64.
12 //
13 class TaggedPointer{
14 public:
15 TaggedPointer(): m\_node(nullptr), m\_counter(0) {}
16
17 Node\* GetNode(){
18 return m\_node.load(boost::memory\_order\_acquire);
19 }
20
21 uint64\_t GetCounter(){
22 return m\_counter.load(boost::memory\_order\_acquire);
23 }
24
25 bool CompareAndSwap(Node\* oldNode, uint64\_t oldCounter, Node\* newNode, uint64\_t newCounter){
26 bool cas\_result;
27 \_\_asm\_\_ \_\_volatile\_\_
28 (
29 "lock;"
30 "cmpxchg16b %0;"
31 "setz %3;"
32
33 : "+m" (\*this), "+a" (oldNode), "+d" (oldCounter), "=q" (cas\_result)
34 : "b" (newNode), "c" (newCounter)
35 : "cc", "memory"
36 );
37 return cas\_result;
38 }
39 private:
40 boost::atomic m\_node;
41 boost::atomic m\_counter;
42 }
43 // Выравнивание по 16 байтам необходимо для правильной работы double cas
44 //
45 \_\_attribute\_\_((aligned(16)));
46
47
48 bool TryPushStack(Node\* entry){
49 Node\* oldHead;
50 uint64\_t oldCounter;
51
52 oldHead = m\_head.GetNode();
53 oldCounter = m\_head.GetCounter();
54 entry->next.store(oldHead, boost::memory\_order\_relaxed);
55 return m\_head.CompareAndSwap(oldHead, oldCounter, entry, oldCounter + 1);
56 }
57
58 bool TryPopStack(Node\*& oldHead, int threadId){
59 oldHead = m\_head.GetNode();
60 uint64\_t oldCounter = m\_head.GetCounter();
61 if(oldHead == nullptr){
62 return true;
63 }
64 m\_hazard[threadId\*8].store(oldHead, boost::memory\_order\_seq\_cst);
65 if(m\_head.GetNode() != oldHead){
66 return false;
67 }
68 return m\_head.CompareAndSwap(oldHead, oldCounter, oldHead->next.load(boost::memory\_order\_acquire), oldCounter + 1);
69 }
70
71 void Push(Node\* entry){
72 while(true){
73 if(TryPushStack(entry)){
74 return;
75 }
76 usleep(250);
77 }
78 }
79
80 Node\* Pop(int threadId){
81 Node\* res;
82 while(true){
83 if(TryPopStack(res, threadId)){
84 return res;
85 }
86 usleep(250);
87 }
88 }
89
90 private:
91 TaggedPointer m\_head;
92 // Умножение на восемь позволяет каждому локальному указателю быть в
93 // своей собственной кеш-линии, что заметно ускоряет работу с ними.
94 //
95 boost::atomic m\_hazard[MAX\_THREADS\*8];
96 };
```
Код бенчмарка также доступен на **github** (если вы хотите запустить тест локально):
<https://github.com/memsql/lockfree-bench>
#### Update:
По предложению [lostmsu](https://habrahabr.ru/users/lostmsu/) добавил в бенчмарк стек со spinlock вместо std::mutex. Для чистоты эксперемента использовал spinlock, который, как и lockfree реализация, спит 250 миллисекунд, если не удается захватить блокировку с первой попытки. *Не* неожиданно, такая реализация оказалась производительнее и lock-free реализации, и реализации с std::mutex. Потребление процессора визуально такое же, как и у lock-free реализации с usleep(250).
[Репозиторий](https://github.com/memsql/lockfree-bench) на гитхабе тоже обновлен с новой реализацией. | https://habr.com/ru/post/174369/ | null | ru | null |
# Как в oneFactor ускорили безопасное обучение ML-алгоритмов в 19 раз с помощью Intel Xeon Gen3 и SGX 2.0
Эксперты [компании oneFactor](https://onefactor.com/) протестировали процессоры Intel Xeon Ice Lake с технологией Intel SGX 2.0 для оценки ускорения процесса машинного обучения на собственной платформе SmartMachine по сравнению с процессорами Intel предыдущего поколения. Результат был получен более чем впечатляющий: ускорение полного цикла обучения составило от 8 до 19 раз в зависимости от размера подаваемых на вход данных. В этой статье oneFactor поделится методикой и деталями тестирования.
О компании oneFactor
--------------------
oneFactor – разработчик платформы SmartMachine для конфиденциального совместного машинного обучения на глобальном графе клиентских связей, которая дает возможность быстро создавать максимально точные сервисы. Технология, лежащая в основе платформы, была запатентована компанией еще в 2019 году.
SmartMachine позволяет конфиденциально объединять данные нескольких компаний и индустрий с использованием аппаратного решения Intel SGX. Платформа запущена в промышленную эксплуатацию в конце 2020 года. С марта 2021 года технология oneFactor позволяет не только исполнять обученные модели в анклаве, но также выполнять их тренировки внутри анклава Intel SGX. На данный момент к SmartMachine уже подключен ряд крупнейших по объему розничного кредитования российских банков.
Тестовый сценарий
-----------------
Один из основных сценариев работы платформы SmartMachine — безопасный тренинг моделей с использованием алгоритмов машинного обучения.
Для обучения используются зашифрованные датасеты в бинарном формате со случайными данными, которые генерируются скриптом на сервере и сохраняются в папку с датасетами /var/ds/1. Приложение с обучающим анклавом запускается в докер-контейнере и монтирует эту папку с датасетами в файловую систему контейнера.
*Cценарий обучения*
Для проведения бенчмарка выбран следующий сценарий обучения:
1. Загрузка файла выборки targets от клиента платформы SmartMachine
2. Подготовка датасетов с фичами для обучения
3. Обучение модели
4. Получение модели и оценка её качества.
5. Расчёт результата для выборки targets.
Интеграция с платформой oneFactor, которая использует технологию SGX для обеспечения безопасных вычислений, идет через gRPC.
Конфигурации тестовых стендов
-----------------------------
*Диаграмма взаимодействия компонент*
Конфигурация ноды тестового кластера на платформе oneFactor на базе Intel CPU c SGX версии 1.0:
| | |
| --- | --- |
| CPU | Intel Xeon E3-1270v5 3.6 ГГц |
| RAM | 64 ГБ DDR4 2133 MHz |
| HDD | 2 × 480 ГБ SSD Intel DC S3500 Series |
| OS | Ubuntu 18.04 5.4.0-66-generic |
Вывод [тестового приложения по определению параметров SGX](https://github.com/ayeks/SGX-hardware/blob/master/test-sgx.c) процессора, установленного на сервере:
`Extended feature bits (EAX=07H, ECX=0H)
eax: 0 ebx: 29c6fbf ecx: 0 edx: 9c002600
**sgx available: 1
sgx launch control: 0**
CPUID Leaf 12H, Sub-Leaf 0 of Intel SGX Capabilities (EAX=12H,ECX=0)
eax: 1 ebx: 0 ecx: 0 edx: 241f
**sgx 1 supported: 1
sgx 2 supported: 0**
MaxEnclaveSize_Not64: 1f
**MaxEnclaveSize\_64: 24 (16 MB)**`
Конфигурация сервера на базе Intel Ice Lake CPU c SGX версии 2.0, предоставленного компанией Intel, для проведения бенчмарка:
| | |
| --- | --- |
| CPU | 2x Intel Ice Lake Xeon, 18 ядер, 2.5 ГГц |
| RAM | 378 ГБ DDR4 2933 MHz |
| HDD | 1 x M.2 NVMe 2TB |
| OS | Ubuntu 18.04 5.4.0-66-generic |
Вывод [тестового приложения по определению параметров SGX](https://github.com/ayeks/SGX-hardware/blob/master/test-sgx.c) процессора, установленного на сервере:
`Extended feature bits (EAX=07H, ECX=0H)
eax: 0 ebx: f3bfb7ef ecx: 40417f5e edx: bc040412
**sgx available: 1
sgx launch control: 1**
CPUID Leaf 12H, Sub-Leaf 0 of Intel SGX Capabilities (EAX=12H,ECX=0)
eax: 463 ebx: 1 ecx: 0 edx: 381f
**sgx 1 supported: 1
sgx 2 supported: 1**
MaxEnclaveSize_Not64: 1f
**MaxEnclaveSize\_64: 38 (256 GB)**`
Ключевая функциональность в SGX 2.0 с точки зрения дальнейшего развития платформы oneFactor — значительно увеличен максимально возможный размер анклава. Поддержка SGX 2.0 реализована в новых процессорах компании Intel — семействе Ice lake.
Результаты тестирования и выводы
--------------------------------
Для обучения использовалось датасеты суммарным объёмом 3.6, 7.2 и 11 Гигабайт. Размеры результирующего датасета на котором обучались модели составляли 20 х 1500000, 20 х 3000000 и 20 х 4500000 соответственно (Матрицы N x M, где N — количество столбцов и M — количество строк). В среднем итераций/шагов обучения — 100-150.
| | | | |
| --- | --- | --- | --- |
| Общий объем датасетов, Гб | Время исполнения
сценариев тренировки, с. | Время загрузки датасетов, с. | Время тренировки моделей, с. |
| | SGX 1.0 | SGX 2.0 | SGX 1.0 | SGX 2.0 | SGX 1.0 | SGX 2.0 |
| 3,6 | 787,7 | 91,1 | 96,5 | 48,7 | 202,3 | 13,9 |
| 7,2 | 1499,8 | 162,1 | 192,7 | 94,9 | 288,2 | 18,9 |
| 11 | 4320,2 | 224,4 | 306 | 142,1 | 1942,5 | 23,2 |
Тесты показали, что использование процессоров Intel Xeon Ice Lake позволяет ускорить обучение алгоритмов на платформе SmartMachine компании oneFactor в 8-19 раз в зависимости от размера подаваемых на вход данных по сравнению с процессорами Intel Xeon предыдущего поколения.
Так, время, требуемое на одну итерацию обучения, включающую загрузку данных в анклав, их подготовку и преобразование, а также само обучение, при размере обучающей выборки 3,6 Гигабайт составило 787 секунд для SGX1 и 91 секунду для SGX2. При размере обучающей выборки равной 11 Гигабайт данное время составило уже 4320 секунд для SGX1 и 224 секунды для SGX2.
Полученные по результатам тестов показатели демонстрируют, что выигрыш по времени увеличивается при росте размеров обучающей выборки: при 3,6 Гб подаваемых на обучение выигрыш составил 8,6 раз; при 11 Гб подаваемых на обучение выигрыш составил уже 19 раз. Также следует учитывать, что для получения промышленной модели платформа SmartMachine производит в среднем 150 итераций и это даёт значительный выигрыш по времени обучения при использовании новых CPU ICX с поддержкой SGX2.
Таким образом, с точки зрения продуктов oneFactor, можно сделать следующие выводы.
* Ключевая компонента платформы SmartMachine, которая обеспечивает безопасное обучение алгоритмов машинного обучения, успешно работает на новых процессорах семейства Ice Lake Intel CPU с поддержкой SGX 2.0.
* Использование Intel SGX 2.0 позволит ускорить обучение моделей от 8 до 19 раз на одной итерации и существенно уменьшит TTM (time-to-market) по созданию новых моделей на платформе oneFactor.
* Использование Intel SGX 2.0 упростит процедуру масштабирования платформы oneFactor в пиковую нагрузку со стороны клиентов | https://habr.com/ru/post/560598/ | null | ru | null |
# Автоматические скриншоты iOS с помощью XCTestplan и XCode 11
*В Райффайзенбанке несколько мобильных приложений, которые должны работать на самых разных девайсах и операционных системах, поэтому мы стараемся автоматизировать рутинные процессы в тестировании. Эта статья показалась нам полезной, и мы решили ее перевести.*
[](https://habr.com/ru/company/raiffeisenbank/blog/502626/)
foto source: unsplash.com
Если ваше приложение мультиязычное, универсальное и рассчитано на разные девайсы, то на создание скриншотов для каждой конфигурации можно потратить много времени. Представьте, у вас четыре языка, поддержка iPad и iPhone и вам нужно сохранить по 4 экрана, — это 32 скриншота. Процесс необходимо автоматизировать, чтобы не тратить время каждый раз, когда обновляются интерфейсы.
Инструмент XCTestPlan, который появился в XCode 11, позволяет нам создавать несколько конфигураций для тестов. Сейчас конфигурации чаще всего применяются, чтобы определить, как тесты будут запускаться, включая выбор языка для приложения. В этой статье вы узнаете, как можно использовать XCTestPlan, чтобы автоматизировать получение скриншотов.
### Запускаем XCTestplan
Давайте настроим отдельный UITests target для автоматизации создания скриншотов, особенно это полезно, если вы не планируете запускать свои основные тесты с этими конфигурациями. Чтобы создать новый таргет, выберите **File -> New -> Target** и создайте новый **UI Testing Bundle**. После этого необходимо добавить новый **XCTestplan** этому таргету. Для этого можно либо использовать меню **Product -> Test Plan -> New Test Plan**, либо в **Scheme Editor** выбрать пункт **Convert to use Test Plans**. Если делать это через меню, то нужно убедиться, что новый таргет есть на вкладке `Test`.
Поскольку мы хотим настроить только параметры языка, то мы можем оставить Shared Settings без изменений и просто добавить по новой конфигурации для каждого языка, который мы поддерживаем. Так выглядят настройки для приложения, поддерживающего английский, немецкий и французский:
Это вся необходимая настройка и запуск XCTestplan.
### Автоматизация создания скриншотов
Ваши UI-тесты, создающие скриншоты, практически ничем не будут отличаться от ваших привычных тестов кроме того, что они будут создавать аттачи. Еще вы можете добавить проверки XCTAssert, чтобы тесты падали, если что-то идет не так.
Другой важный момент: вам может понадобиться **waitForExpectations** на случай, если ваш UI не будет готов к моменту создания скриншота (появление/скрытие клавиатуры, завершение анимации).
Ниже приведен пример со всеми вспомогательными методами:
```
func testScreenshots() {
let app = XCUIApplication()
let searchButton = app.buttons["search"]
searchButton.tap()
let keyboard = app.keyboards.firstMatch
waitForExistence(of: keyboard)
app.typeText("Cupertino")
add(takePromoShot(name: "Search"))
let firstResult = app.cells.firstMatch
firstResult.tap()
waitForDisappearance(of: keyboard)
add(takePromoShot(name: "Result"))
}
```
```
func waitForExistence(of element: XCUIElement) {
let predicate = NSPredicate(format: "exists == TRUE")
expectation(for: predicate, evaluatedWith: element, handler: nil)
waitForExpectations(timeout: 5.0, handler: nil)
}
```
```
func waitForDisappearance(of element: XCUIElement) {
let predicate = NSPredicate(format: "exists == FALSE")
expectation(for: predicate, evaluatedWith: element, handler: nil)
waitForExpectations(timeout: 5.0, handler: nil)
}
```
```
func takePromoShot(name: String) -> XCTAttachment {
let lang = Locale.preferredLanguages[0]
let screenshot = XCUIScreen.main.screenshot()
let attachment = XCTAttachment(screenshot: screenshot)
attachment.lifetime = .keepAlways
attachment.name = "\(lang)-\(name)"
return attachment
}
```
Обратите внимание на последнюю функцию. Она принимает название снимка, добавляет идентификатор языка, делает скриншот и возвращает XCTAttachment со значением параметра **.keepAlways**. Это важно, так как по умолчанию скриншоты, сделанные во время тестов, удаляются, если тесты проходят успешно. **Lifiteme** важный параметр, поскольку он гарантирует, что скриншот сохранится после того, как тест будет завершен. Во время UI-тестов постоянно снимаются скриншоты. Они очень полезны, когда нужно определить, почему и когда тест упал; но по умолчанию скриншоты будут удалены, если тесты прошли успешно. Таким образом, когда тест **testScreenshots()** пройдет успешно, у вас останутся только необходимые скриншоты.
### Привычный статус-бар
Большинство разработчиков предпочитают видеть на своих скриншотах статус-бар с нужным временем, полным сигналом сети и прочими деталями. В Xcode 11 это делается еще проще. Есть утилита **xcrun simctl status\_bar**, которая позволяет задать эти настройки. Это можно добавить как **Build Phase**:
```
xcrun simctl status_bar booted override --time 9:41 --operatorName ' ' --cellularMode active --cellularBar 4 --wifiBars 3 --batteryState charged
```
После этой команды статус-бар будет выглядеть так же, как в маркетинговых материалах Apple. К сожалению, команда не сработает на реальном девайсе, только в симуляторе. Еще надо отметить, что симулятор, который вы используете, должен быть запущен до того, как вы начнете тесты для сбора скриншотов.
### Сбор получившихся скриншотов
Теперь мы можем запускать наши UI-тесты. Когда они пройдут, мы увидим результаты в **Report Navigator** в Xcode. Тут же будут тесты, содержащие в себе процедуры, сгруппированные по языковым конфигурациям. Процедуры, у которых есть аттачи, помечены скрепкой. Сами изображения можно открыть в **QuickLook**.
Собирать по отдельности все получившиеся снимки может быть очень трудозатратно, особенно если ваше приложение поддерживает много языков. К сожалению, эти аттачи не оказываются в виде png или jpg среди результатов тестов (еще одно изменение в Xcode 11). Но можно спарсить результаты тестов и найти JSON, который укажет на реальные аттачи и соберет их. Это можно сделать [с помощью утилиты xcparse](https://github.com/ChargePoint/xcparse). Она устанавливается с помощью Homebrew и запускается командой:
```
xcparse screenshots /path/to/Test.xcresult /path/to/outputDirectory
```
Дополнительные флаги сгруппируют файлы по устройству, ОС или конфигурации. Названия наших файлов содержат идентификатор языка, поэтому можно просто отсортировать их по имени.
### Заключение
Описанный подход уже позволил нам сэкономить достаточно времени, особенно в ситуациях, когда появлялось требование поддерживать устройство с новым разрешением или значительно обновлялся интерфейс. На WWDC20 хотелось бы увидеть выбор девайсов как часть конфигурации XCTestplan, а пока что приходится выбирать вручную или использовать скрипт, который собирает необходимые для скриншотов в AppStore. | https://habr.com/ru/post/502626/ | null | ru | null |
# Детектор углекислого газа MT8057S. НЕобзор с участием НЕэмулятора
— Привет, Хабр! Гляди!
— Мужик, ты чё? Этим детектором без тебя уже весь ресурс вдоль и поперёк… А тут ещё ты. Сколько можно одну и ту же тему мусолить-то?
— Спокуха, пацаны! Конечно, я не собираюсь повторять уже имеющиеся обзоры. Что это, зачем это, как работает, как пользоваться, что внутри… А органично эти обзоры дополню тем, что предыдущие обзорщики не сделали. А именно, проверю, запустится ли ПО для этого детектора в одном известном НЕэмуляторе (том, который «is not an emulator») и увидит ли висящий на порте прибор. Получится — отлично, не получится — отрицательный результат в науке тоже считается результатом.
Спойлер: я криворук, так что фейл, но найдено другое решение, для которого НЕэмулятор не пригодился.
Ну что, НЕэмулятор у нас бодро качается:
А пока сначала посмотрим вывод lsusb:
```
$ lsusb
Bus 002 Device 004: ID 138a:0011 Validity Sensors, Inc. VFS5011 Fingerprint Reader
Bus 002 Device 005: ID 0cf3:3004 Atheros Communications, Inc. AR3012 Bluetooth 4.0
Bus 002 Device 002: ID 0438:7900 Advanced Micro Devices, Inc.
Bus 002 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 001 Device 004: ID 5986:0652 Acer, Inc
Bus 001 Device 003: ID 89e5:1001
Bus 001 Device 002: ID 0438:7900 Advanced Micro Devices, Inc.
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 004 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub
**Bus 003 Device 002: ID 04d9:a052 Holtek Semiconductor, Inc.**
Bus 003 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
```
Вот то, что от Holtek — это и есть оно. При отключении исчезает. Теперь скачаем ПО, которое мы «скормим» Wine, как только он установится:
ПО скачалось, НЕэмулятор тоже, попробуем запустить одну из программулин:
Никаких установщиков, программа «портативная». Работает сразу, но воткнутый девайс не видит. Попробуем настроить:
Можно попробовать выбрать USB и восемь разных COM-портов. Поначалу я на это купился и попробовал известные способы проброса USB-COM в Wine. При подключении прибора появляется устройство /dev/usb/hiddev0, которое я и принял за такой порт. Но пробросить его не вышло, ибо… Не будем забегать вперёд. Сначала другую программку проверим.
Почти близнец. Только меню чуть отличается. Лезем в настройки:
И результат, разумеется, аналогичен. И неудивительно: само название hiddev0 говорит о том, что это не USB-COM, а USB-HID-устройство. Поиск по форумам показал, что таковые в стабильном Wine не поддерживаются. К тому же, если chmod'ом обеспечить доступ к hiddev0 непривилегированным пользователям, то после каждого отключения и подключения детектора устройство снова становится доступным только руту. Но даже когда оно доступно всем, Wine думает, что его нет.
Запустить Wine от рута? Не рекомендуется, но допустим, этим двум программам я доверяю. Пробую… Облом, НЕэмулятор вообще отказывается под рутом запускаться. Папка .wine не твоя, говорит. Оказывается, надо не sudo wine, а сначала sudo su, потом wine делать, и он в папке /root тоже папку .wine создаст. Только от этого не изменилось ничего.
Что ж, есть ещё нативный линуксовый co2mon. Только скачать его я решил в другом месте — там, где он уже скомпилирован.
→ [Вот тут](https://altlinux.pkgs.org/sisyphus/classic-i586/co2mon-2.1.0-alt1.i586.rpm.html)
После того, как RPM выкачался, я установил его своим любимым способом. А именно, взялся за mc и ручками под рутом раскидал файлы из папки CONTENTS.cpio в архиве по тем папкам файловой системы, где им положено быть.
Запускаем co2mond, а оно хочет libhidapi-libusb0. Немного гугления-яндексения, и выясняется, что для этого надо скормить ему пакет libhidapi-dev:
```
$ sudo apt-get install libhidapi-dev
```
Пакет бодро ставится, запускаю и вижу:
```
$ co2mond
hid_open: error
Unable to open CO2 device
hid_open: error
hid_open: error
hid_open: error
hid_open: error
hid_open: error
hid_open: error
hid_open: error
hid_open: error
hid_open: error
```
Ах, да, я же перетыкал устройство. Снова chmod'ом делаю, чтобы hiddev0 был доступен непривилегированным пользователем, запускаю и вижу то же самое. Тогда запускаю co2mond от рута, и — успех!
```
$ sudo co2mond
[sudo] пароль для username: КОШКА
Tamb 25.1000
Tamb 25.1000
Tamb 25.1000
Tamb 25.0375
CntR 1617
Tamb 25.0375
CntR 1617
Tamb 25.1000
CntR 1617
Tamb 25.1000
CntR 1617
Tamb 25.0375
CntR 1617
Tamb 25.1000
CntR 1617
Tamb 25.0375
CntR 1617
Tamb 25.1000
CntR 1617
Tamb 25.1000
CntR 1617
Tamb 25.1000
```
Пока датчик не разогрет, выводится только Tamb — temperature ambient, как я понял. Как разогреется — ещё и CntR (content of чего-то на R, не знаю синонимов углекислого газа на R).
Если на встроенном дисплее прибор показывает температуру с одним знаком после запятой, то в компьютер выводит аж с четырьмя! Действительно ли там настолько точный термодатчик? Не знаю. Ну а показания содержания углекислого газа приходят с той же точностью, что на встроенном дисплее, только завышенными на несколько единиц.
Ну, думаю, раз в процессе установки линуксового ПО файл 99-co2mon.rules с прописанными данными, совпадающими с увиденными в lsusb, оказался на своём месте, может, заработают и те программы, которые я пробовал запустить в Wine. Нет, не в этом файле дело. По-прежнему ни так, ни под рутом не хочет. Похоже, без экспериментального Wine с поддержкой USB-HID или каких-нибудь патчей не обойтись.
Вот, собственно, и всё. Оно заработало, но не так, как хотелось бы: та программа, которая «завелась», не выводит графиков. Считать ли это отрицательным результатом, или нет, ведь вытащить данные из прибора удалось? А Wine за годы своего существования весьма «повзрослел». По сравнению с тем, что было несколько лет назад, его просто не узнать, многие программы работают в нём так, как будто написаны специально для него. Только интровертом оказался — с некоторыми желёзками общаться боится. Десятипроцентная скидка на девайс — по [ссылке](http://goo.gl/grmgSo) с промокодом TORMOZ CO2.
Таким образом, среднестатистическому Linux-пользователю, подкованному на уровне азов работы с командной строкой, но не умеющему или не желающему возиться с патчами и экспериментальными сборками программ, сопрячь это устройство с компьютером удастся. Но та программа, которая сможет наладить с прибором диалог, будет минималистической. Всё сказанное касается и других устройств того же назначения на том же Holtek'овском чипе.
P.S. Через отверстия для вентиляции видно, как в корпусе прибора периодически вспыхивает… «лампочка Ильича». Я читал об этом в старых обзорах, но думал, что у меня устройство более новой версии, где применён светодиод. Нет. Значит, это принципиально — нужен спектр без «горбов».
Всем спасибо за внимание! | https://habr.com/ru/post/430916/ | null | ru | null |
# Интеграция и серверная валидация инаппов для стора Google Play — как защититься от читеров
Онлайн-проекты рано или поздно сталкиваются со взломом внутреннего стора, когда читеры накручивают себе игровые предметы, оружие или валюту. Классика. Наш PvP-шутер не стал исключением — брешь мы в итоге закрыли, хотя и пришлось повозиться.
В этой статье расскажу про интеграцию и серверную валидацию инаппов с точки зрения клиента: какой плагин использовать для Google Play и на что обращать внимание независимо от платформы, а моя коллега поделится кодом серверной части.
Как уже говорилось в блоге, наш флагманский проект — это мобильный PvP-шутер с DAU около 1 млн пользователей, большинство из которых на Android. В игре сотни видов оружия и предметов. И чтобы защититься от взлома, естественно, нужна валидация покупок. Пойдем по порядку.
В Google Play наш проект использует consumable in-apps, которые после успешной покупки и валидации начисляются игроку и сразу потребляются. По историческим причинам для Google Play мы используем [плагин от Prime31](https://prime31.com/docs#androidIAB).
Отмечу, что если бы мы сегодня добавляли встроенные покупки с нуля на эти платформы, то взяли бы [Unity IAP](https://unity3d.com/ru/unity/features/iap) (а, например, на Huawei публиковались бы через [Unity Distribution Portal](https://unity.com/ru/products/unity-distribution-portal)).
В игре много спецпредложений, но мы не стали заводить отдельный id инаппа под каждую акцию, вместо этого используем один набор айдишников инаппов для разных предметов и предложений. В момент нажатия на конкретную покупку мы запоминаем контент, который нужно выдать игроку при успешной покупке. При завершении покупки — выдаем его.
Перейдем к коду покупки и валидации инаппов.
На старте приложения подписываемся на события покупки:
```
// GoogleIABManager — класс из плагина Prime31
GoogleIABManager.purchaseSucceededEvent += HandleGooglePurchaseSucceeded;
```
Когда игрок нажимает на инапп в интерфейсе — запускаем покупку:
```
// GoogleIAB — класс из плагина Prime31
GoogleIAB.purchaseProduct(productId);
```
В обработчике успешного завершения покупки оборачиваем платформо-специфичную покупку в объект, реализующий IMarketPurchase. IMarketPurchase мы используем на всех платформах, чтобы сделать код валидации кроссплатформенным. В этот интерфейс мы оборачиваем классы из плагинов конкретных магазинов.
```
public interface IMarketPurchase
{
string ProductId { get; }
string OrderId { get; }
string PurchaseToken { get; }
object NativePurchase { get; }
}
class GoogleMarketPurchase : IMarketPurchase
{
internal GoogleMarketPurchase(GooglePurchase purchase)
{
_purchase = purchase;
}
public string ProductId => _purchase.productId;
public string OrderId => _purchase.orderId;
public string PurchaseToken => _purchase.purchaseToken;
public object NativePurchase => _purchase;
private GooglePurchase _purchase;
}
internal static class MarketPurchaseFactory
{
// GooglePurchase — класс из плагина Prime31
internal static IMarketPurchase CreateMarketPurchase(GooglePurchase purchase)
{
return new GoogleMarketPurchase(purchase);
}
}
private void IapManagerOnBuyProductSuccess(PurchaseResultInfo purchaseResult)
{
var purchaseData = new InAppPurchaseData(purchaseResult.InAppPurchaseData);
IMarketPurchase marketPurchase = MarketPurchaseFactory.CreateMarketPurchase(purchaseData);
ValidatePurchase( marketPurchase );
}
```
Отправляем покупку на наш сервер на валидацию:
```
private void ValidatePurchase(IMarketPurchase purchase)
{
var request = new InappValidationRequest
{
orderId = purchase.OrderId,
productId = purchase.ProductId,
purchaseToken = purchase.PurchaseToken,
OnSuccess = () => ProvidePurchase(purchase),
OnFail = () => Consume(purchase)
};
WebSocketCallbacks.Subscribe(ServerEventNames.PurchasePrevalidate, PrevalidatePurchaseHandler);
Dictionary data = new Dictionary();
data.Add("orderId", request.orderId);
data.Add("productId", request.productId);
data.Add("data", request.purchaseToken);
int reqId = WebSocketManager.Instance.Send(ServerEventNames.PurchasePrevalidate, data);
\_valdationRequests.Add(reqId, request);
}
```
Если валидация проходит неуспешно — потребляем (Consume) продукт без начисления пользователю.
Если все хорошо — потребляем продукт с начислением пользователю:
```
void ProvidePurchase(IMarketPurchase purchase)
{
GiveInGameCurrencyAndItems(purchase);
Consume(purchase);
}
```
Важный момент: метод Consume перед отправкой в магазин запроса на потребление запоминает, что мы уже начислили покупку игроку. Это нужно, если из-за проблем с сетью (или каких-то других) запрос на консьюм не дойдет до магазина. В таком случае, когда после перезапуска приложения нам придут незаконсьюмленные покупки, мы увидим, за какие из них уже начисляли игроку валюту и предметы.
Обработчик ответа с сервера:
```
private const int ERROR_CODE_SERVER_ERROR = 30;
private const int ERROR_CODE_VALIDATION_ERROR = 31;
private void PrevalidatePurchaseHandler(Dictionary response)
{
int reqId = Convert.ToInt32(response["req\_id"], CultureInfo.InvariantCulture);
\_valdationRequests.TryGetValue(reqId, out InappValidationRequest request);
if (request == null)
return;
\_valdationRequests.Remove(reqId);
if (response["status"].Equals("ok"))
{
request.OnSuccess();
}
else
{
int code = Convert.ToInt32(response["err\_code"], CultureInfo.InvariantCulture);
switch (code)
{
case ERROR\_CODE\_VALIDATION\_ERROR:
request.OnFail();
break;
case ERROR\_CODE\_SERVER\_ERROR:
CoroutineRunner.DeferredAction(5f, () => TryValidateAgain());
break;
default:
// неизвестная ошибка, начисляем инапп (поступаем в пользу игрока)
request.OnSuccess(null);
break;
}
}
}
```
В случае, если сервер вернул OK в статусе валидации, производим начисление и консьюм покупки. Если сервер вернул неизвестную ошибку, трактуем результат валидации в пользу игрока.
Для следующего раздела передаю слово нашему серверному программисту [Ире Поповой](https://habr.com/ru/users/ipopova/).
### Серверная валидация
Валидация на сервере состоит из двух этапов:
* превалидация — когда данные по платежу отправляются на сервер соответствующей платформы для проверки валидности;
* начисление — в случае успешно пройденной валидации купленных позиций.
Сначала сервер получает в качестве входных параметров данные, необходимые для проведения валидации. В Android — это id позиции и токен. Методы валидации являются платформо-зависимыми. Но, как правило, включают в себя логику отправки данных на сервер валидации соответствующей платформы, обработку полученного результата и возврат соответствующего ответа на клиент. Дополнительно результат валидации записывается в redis для последующей быстрой проверки при начислении.
```
def validate_receipt(self, uid, data, platform):
InAppSlot = PlayerProgress.first(f"player_id={uid} AND slot_id='35'")
if not InAppSlot:
raise RuntimeError(f"Fail get slot purchases: not found player:{uid} data:{data}")
tid = data.get("tid")
params = []
orders_data = []
valid_orders = []
if not tid or tid in InAppSlot.content:
return False
params = str(tid).split(self.IN_APP_ID_SEPARATOR)
if platform == "ios":
transaction_id = params[0]
product_id = params[1]
orders_data = self._get_receipt_ios(data.get("data"), data.get("test") == 1, transaction_id, product_id)
error("[VALIDATION] {} {} {}".format(transaction_id, product_id, orders_data))
elif platform == "android":
product_id = params[1]
purchase_token = data.get("data")
orders_data = self._get_receipt_android(product_id, purchase_token)
elif platform == "amazon":
receipt_sku = params[0]
user_id = params[1]
orders_data = self._get_receipt_amazon(user_id, receipt_sku)
elif platform == "huawei":
product_id = params[1]
orders_data = self._get_receipt_huawei(product_id, tid, data.get("data", ""), data.get("account_flag", 0))
elif platform == "udp":
product_id = params[1]
orders_data = self._get_receipt_udp(product_id, params[0], data.get("data", ""))
elif platform == "samsung":
product_id = params[1]
transaction_id = params[0]
product_id = params[1]
orders_data = self._get_receipt_samsung(data.get("data", ""), product_id)
else:
error("[InAppValidator] unknown platform")
return False
if not orders_data:
error(f"[InAppValidator] fail get receipt {platform} player:{uid} data:{data}")
return False
key = f"inapp:{uid}:{tid}"
for order in orders_data:
if not order.is_success():
continue
valid_orders.append(order)
try:
self.inapp_redis.setex(key, order.to_json(), 86400)
except Exception as ex:
exception(f"[InAppValidator] fail save inapp to redis: {ex}")
if not valid_orders:
warning(f"[InAppValidator] not valid receipt {orders_data[0].order_id}")
return False
return True
```
Пример получения данных с соответствующего сервера валидации для Android. Для обращения к серверу Google были использованы пакеты Google для Python apiclient и oauth2client.
```
def _get_receipt_android(self, product_id, token):
if not self.android_authorized:
self._android_auth()
debug(f"[InAppValidator] android product_id: {product_id}, token: {token}")
try:
product = self.android_publisher.purchases().products().get(
packageName=config.GOOGLE_SERVICE_ACCOUNT['package_name'], productId=product_id, token=token).execute()
except client.AccessTokenRefreshError:
self.android_authorized = False
return self._get_receipt_android(product_id, token)
except google_errors.HttpError as ex:
if ex.resp.status == 401 or ex.resp.status == 503:
self.android_authorized = False
return self._get_receipt_android(product_id, token)
return False
if not product:
warning("[InAppValidator] android product is NONE")
return None
order_id = product.get('orderId')
if not order_id:
warning(f"order_id is NONE: {product}")
return None
return [Receipt(order_id, product.get('purchaseState', -1), product_id)]
class Receipt:
def __init__(self, order_id, status, product_id, user_id=None, expire=0, trial=0, refund=0, latest_receipt=''):
self.order_id = order_id
self.status = status
self.product_id = product_id
self.user_id = user_id
self.expire = expire
if str(trial) == 'true':
self.trial = 1
else:
self.trial = 0
self.refund = refund
self.latest_receipt = latest_receipt
def is_success(self):
return self.status == 0
def is_canceled(self):
return self.status == 3
def is_valid(self):
return self.order_id and self.product_id
def to_dict(self):
return {"id": self.order_id, "s": self.status, "p": self.product_id, "u": self.user_id, "e":self.expire, "t":self.trial,"r":self.refund,"lr":self.latest_receipt}
def to_json(self):
return json.dumps({"id": self.order_id, "s": self.status, "p": self.product_id, "u": self.user_id, "e":self.expire, "t":self.trial,"r":self.refund,"lr":self.latest_receipt})
```
Отдельной командой/набором команд происходит начисление купленных позиций. Одна позиция может содержать разнотипные итемы (например, деньги и оружие), и для каждого типа итема на сервере существует отдельная команда начисления.
Чтобы логически объединить несколько команд, привязанных к одному действию игрока, на клиенте и на сервере введено понятие снапшота — специальной конструкции, представляющей собой объединение команд, в которой ни одна команда не выполнится, если хотя бы какая-то не пройдет проверку. Можно сказать, что это некий аналог транзакций в БД. В данном случае снапшот включает специальную команду валидации и команды начисления купленных позиций.
Команда валидации:
```
def validate_receipt(self, data):
neededSlotsNames = [self.slotName]
self.slots = self.get_slots_data(*neededSlotsNames)
InAppSlot = self.slots.get(self.slotName, [])
tid = data.get("tid")
platform = data.get("pl")
params = []
orders_data = []
valid_orders = []
if not tid:
self.ThrowFail("not found required parameter")
elif tid in InAppSlot:
self.ThrowFail("already in slot")
if not self.IsFail():
params = str(tid).split(self.IN_APP_ID_SEPARATOR)
if not self.IsFail():
inapp_storage = InappStorage.get_instance()
if inapp_storage.exists_transaction(self.platform, params[0]):
self.ThrowFail("already_purchased {0} d".format(params[0]),
VALIDATOR_RESULT_CODE.ALREADY_PURCHASED)
self.FinalizeRequest({self.slotName: InAppSlot}, data)
return
# Try get from redis
player_platform = self.platform
if platform is not None and int(platform) == 4:
player_platform = "udp"
_prevalidate_order = self.inapp_redis.check_tid(self._player_id, tid)
if _prevalidate_order:
orders_data = Receipt.from_json(_prevalidate_order)
elif player_platform == "ios":
transaction_id = params[0]
product_id = params[1]
if not transaction_id or not product_id:
self.ThrowFail(f"fail get receipt {self.platform}")
else:
orders_data = self._get_receipt_ios(data.get("data"), data.get("test") == 1, transaction_id, product_id)
elif player_platform == "android":
product_id = params[1]
purchase_token = data.get("data")
orders_data = self._get_receipt_android(product_id, purchase_token)
elif player_platform == "amazon":
receipt_sku = params[0]
user_id = params[1]
orders_data = self._get_receipt_amazon(user_id, receipt_sku)
elif player_platform == "huawei":
product_id = params[1]
orders_data = self._get_receipt_huawei(product_id, tid, data.get("data", ""),
data.get("account_flag", 0), data.get("subscribe"))
elif platform == "udp":
product_id = params[1]
orders_data = self._get_receipt_udp(product_id, params[0], data.get("data", ""))
elif platform == "samsung":
product_id = params[1]
transaction_id = params[0]
product_id = params[1]
orders_data = self._get_receipt_samsung(data.get("data", ""), product_id)
else:
self.ThrowFail("unknown platform")
if not orders_data:
self.ThrowFail(f"fail get receipt {player_platform} {self.platform}")
if not self.IsFail():
for order in orders_data:
if order.is_success():
valid_orders.append(order)
if not valid_orders:
self.ThrowFail("already_purchased {0}".format(orders_data[0].order_id),
VALIDATOR_RESULT_CODE.ALREADY_PURCHASED)
else:
InAppSlot.append(tid)
self.SetRequestSuccessful()
if self._player_id in LOG_PLAYER_IDS:
HashLog.error(f"[INAPP] id:{self._player_id} receipt:{data}")
self.FinalizeRequest({self.slotName: InAppSlot}, data)
```
Команда валидации проверяет транзакцию — если есть данные превалидации, то используются они. В противном случае, данные отправляются на сервер валидации для соответствующей платформы.
В случае успешного начисления, id транзакции сохраняется в соответствующий слот игрока — запись в БД, которая хранит данные по платежным транзакциям данного игрока. Во избежание взлома платежки методом, когда одну валидную транзакцию используют для многократного начисления, в рамках валидации осуществляется проверка на существование данного id транзакции.
Кроме того, в завершение начисления отправляется соответствующая статистика на сервер аналитики.
### На что еще обратить внимание
Вне зависимости от платформы, для которой реализуются встроенные покупки, важно проверить и обработать следующие ситуации:
1. При показе нативных окон магазина в процессе покупки игра может вылететь по памяти. Поэтому следует протестировать такой сценарий, чтобы удостовериться, что покупка после перезапуска корректно завершается и начисляется игроку.
2. На большинстве платформ в процессе взаимодействия с окнами платформенного магазина приложение уходит в бэкграунд, и при завершении покупки выводится из бэкграунда. За это время игра вполне может дисконнектнуться от серверов. Если для валидации или начисления покупки нужен коннект с сервером, то после возвращения в приложение нужно будет соединиться с ним вновь, и только потом производить валидацию или начисление.
3. Нужно тестировать сценарий, когда во время покупки и валидации игрок запускает новую покупку. Мы после тестирования этого сценария обнаружили баги и добавляли запрет запуска покупки, пока идет покупка другого инаппа.
### Дополнительные ссылки
И последнее: когда мы реализовывали валидацию инаппов для Google Play несколько лет назад, нам оказалось полезной [статья на Хабре](https://habr.com/ru/post/313416/), вам она тоже может пригодиться.
Также использовали решения, предложенные [здесь](https://stackoverflow.com/a/51858290/307547) и [здесь](https://stackoverflow.com/a/34005001/307547). Ссылка на документацию по API серверной валидации Google — [здесь](https://developers.google.com/android-publisher/api-ref/rest/v3/purchases.products/get). | https://habr.com/ru/post/559020/ | null | ru | null |
# «Пасхальные яйца» в Ubuntu!
Как все мы знаем, использовать Linux — одно удовольствие. Программисты также любят немного повеселиться. Некоторые из приведенных приколов («пасхальных яиц») специфичны для Ubuntu, некоторые работают во всех дистрибутивах. Давайте начнем.
(Перевод сделан для сайта [linux-digg.ru](http://linux-digg.ru/)).
Первое: программа moo в Ubuntu. Введите в терминале
`aptitude -v moo`
Будет выдано сообщение:
`В этой программе на самом деле нет пасхальных яиц.`
Это значит, что пасхальные яйца в программе moo все-таки есть. Увеличивая количество 'v' в этой команде, можно получить другие сообщения (максимально 5; *прим. переводчика: на самом деле 6, включая рисунок слона, которого проглотила змея*). Когда вы будете готовы увидеть корову, введите
`apt-get moo`
После этого можно перейти к независящим от дистрибутива приколам. Если вы используете GNOME, нажмите alt+F2 и введите “gegls from outer space” без кавычек. Это игра «Space Invaders» с коровами! Забавно, не правда ли?
В OpenOffice есть несколько «пасхальных яиц» В программе Calc введите
`=Game("StarWars")`
в любой ячейке и нажмите «enter». Еще одна версия «Space Invaders»! Правда довольно медленная и трудно попасть. Есть еще несколько игр в OpenOffice, и они работают в Linux, в Windows и даже на mac в NeoOffice!
`=Game("Froggle")`
Запустит игру «Frogger»! Остальные описаны в [Wiki](http://wiki.services.openoffice.org/wiki/Easter_Eggs "Пасхальные яйца в Open Office").
Ну что ж, пока все. В интернете упоминаются и другие приколы, но у меня они не заработали. Можно поискать еще на [FastTrack](http://blog.fasttracksites.com/index.php?p=viewentry&id=5 "Больше пасхальных яиц!"). Веселитесь! И если найдете еще, дайте мне знать! | https://habr.com/ru/post/31185/ | null | ru | null |
# TypeScript 4.9: что нас ожидает
В сентябре этого года Microsoft анонсировал TypeScript 4.9 beta. В бета-версии появились любопытные нововведения и исправления: новый оператор, оптимизация производительности, улучшения существующих типов…
Меня зовут Екатерина Семенова, я — фронтенд-разработчик в [Surf](https://t.me/surf_tech). Давайте вместе разберём самые интересные фичи этого анонса.
Новый оператор satisfies
------------------------
*TL;DR Позволяет делать неоднородные наборы типов более гибкими.*
Чтобы понять, зачем нужен оператор satisfies, рассмотрим пример переменной-записи, где данные имеют смешанный характер. Положим, что значения этой записи могут быть как строками, так и числами.
```
type ComponentKey = 'component1' | 'component2' | 'component3';
const data: Record = {
component1: 0,
component2: '',
component3: 42,
};
const firstResult = data.component1 + 42;
const secondResult = data.component2.toUpperCase();
```
Если мы попытаемся работать с объектом `data` далее, неизбежно наткнёмся на ошибки типов:
```
Operator '+' cannot be applied to types 'string | number' and 'number'.
Property 'toUpperCase' does not exist on type 'string | number'.
Property 'toUpperCase' does not exist on type 'number'.
```
Это объясняется тем, что `number | string` — это объединение. TypeScript разрешает операцию над объединением только в том случае, если она действительна для каждого члена объединения.
TypeScript 4.9 beta предлагает выход: использовать новый оператор satisfies, который позволит безболезненно указывать, какому именно типу удовлетворяет объект.
```
type ComponentKey = 'component1' | 'component2' | 'component3';
const data = {
component1: 0,
component2: '',
component3: 42,
} satisfies Record;
const firstResult = data.component1 + 42;
const secondResult = data.component2.toUpperCase();
```
Компиляция проходит без ошибок. Попробуем поменять значение в `component2`, чтобы убедиться, что новый оператор действительно приводит объект к нужному типу:
```
type ComponentKey = 'component1' | 'component2' | 'component3';
const data = {
component1: 0,
component2: 44,
component3: 42,
} satisfies Record;
const firstResult = data.component1 + 42;
const secondResult = data.component2.toUpperCase();
```
И, как и ожидалось, увидим ошибку:
```
Property 'toUpperCase' does not exist on type 'number'.
```
Таким образом мы сохраняем контроль над типами, и работа с записями становится удобнее.
[Подробнее про оператор, примеры использования, спорные моменты](https://github.com/microsoft/TypeScript/issues/47920)
Умный in
--------
*TL;DR В операторе in станет меньше ошибок при сужении типов.*
Оператор `in` в JavaScript проверяет, существует ли свойство у объекта. Это удобно для данных, чей тип мы не знаем: например, для данных файлов конфигураций.
В TypeScript оператор `in` часто используется, чтобы проверить, входит ли свойство в объект определённого типа. Пример:
```
interface Bird {
fly(): void;
layEggs(): void;
}
interface Fish {
swim(): void;
layEggs(): void;
}
function isFish(creature: Fish | Bird): creature is Fish {
return 'swim' in creature;
}
```
`isFish` — это предикат, который определяет принадлежность параметра `creature` типу `Fish`. Для этого выполняется проверка: если свойство `swim` содержится в объекте, то очевидно, что параметр `creature` относится к типу `Fish`.
Возвращаемый тип функции `isFish` помогает при вызове функции неявно привести параметр `creature` к нужному типу, по сути сузив его:
```
function action(creature: Fish | Bird) {
if (isFish(creature)) creature.swim(); // Это Fish
else creature.fly(); // А это Bird
}
```
Но что, если тип объекта, в котором проверяется наличие свойства, неизвестен? Что будет, если мы попробуем проверить, существует ли свойство в объекте с заранее неизвестным типом? Рассмотрим следующий пример, более приближенный к жизни:
```
function getConfigVersion(config: unknown) {
if (config && typeof config === 'object') {
if ('version' in config && typeof config.version === 'string') {
return config.version;
}
}
return undefined;
}
```
В этом примере мы пытаемся получить свойство `version` из параметра, чей тип невозможно предсказать заранее. В первой проверке неявно приводим `config` к типу `object`*,* во второй убеждаемся, что свойство `version` типа `string` есть в объекте. Но почему-то получаем ошибки:
```
Property 'version' does not exist on type 'object'.
Property 'version' does not exist on type 'object'.
```
В чем дело? Оказывается, оператор `in` строго ограничен типом, который фактически определяет проверяемую переменную. Тип переменной `config` уже известен как `object`*,* соответственно, ни к чему другому приведение в данном случае невозможно: дальнейшая работа с переменной затруднительна.
TypeScript 4.9-beta исправляет это поведение. Вместо того, чтобы оставлять объект «как есть», добавляет к типу `Record<"property-key-being-checked", unknown>` . Переменная `config` после всех проверок будет иметь тип `object & Record<"version", unknown>`*,* что позволит функции выполниться без ошибок.
Больше информации по теме — [в гитхабе Microsoft](https://github.com/microsoft/TypeScript/pull/50666)
Not a number
------------
*TL;DR Прямое сравнение с NaN теперь запрещено.*
NaN — это специальное числовое значение, обозначающее что угодно, но не число. NaN — единственное значение в JavaScript, которое при сравнении с самим собой с помощью оператора строгого равенства (===) дает false. То же происходит при сравнении с любыми другими значениями. То есть ничто не может быть равно NaN — даже NaN!
Примеры типов операций, которые возвращают NaN:
1. Неудачное преобразование чисел. Например, `parseInt("not_a_number")`.
2. Математическая операция, результат которой не является действительным числом. Например, `Math.sqrt(-1)`*.*
3. Метод или выражение, операнд которого является NaN или приводится к нему. Например, 42 \* NaN.
То есть наткнуться на NaN в своем коде вполне реально. Это приводит к тому, что разработчики могут случайно сравнить результат операции напрямую с NaN:
```
parseInt(someValue) !== NaN
```
Что, как следует из определения, приведёт к логической ошибке, которую можно сразу не заметить: выполнить такую проверку ничто не мешает, и разработчик всегда будет получать `true`.
Решение проблемы — запрет на прямое сравнение с `NaN`*.* В бета-версии TypeScript 4.9 сравнение возможно только через специальный метод `Number.isNaN`, который позволит избежать логических ошибок при сравнении.
Теперь разработчики видят ошибку:
```
TS2845: This condition will always return 'true'.
Did you mean '!Number.isNaN(...)'?
```
Отслеживание изменений
----------------------
*TL;DR Изменена стратегия по умолчанию для отслеживания изменений — механизм File System Events.*
В более ранних версиях TypeScript для отслеживания изменений использовалась стратегия опроса — pooling: периодическая проверка состояния файла на наличие обновлений. В этом подходе есть плюсы и минусы. Например, такой способ отслеживания изменений считается более надежным и предсказуемым на разных платформах и файловых системах. Однако если кодовая база большая, то отслеживание изменений путём опроса может серьезно повысить нагрузку на ЦП и привести к перерасходу ресурсов.
В TypeScript 4.9 стратегией по умолчанию станет механизм *событий файловой системы — File System Events.* Он основывается на подписке на событие изменения файлов и выполнение кода только тогда, когда это событие произошло. Таким образом, отпадает необходимость периодических опросов. Для большинства разработчиков это нововведение должно обеспечить гораздо более комфортный опыт при работе в режиме `--watch` или при работе с редактором на основе TypeScript.
Настроить отслеживание изменений по-прежнему можно с помощью переменных среды и watchOptions.
Подробнее — [в хендбуке TypeScript](https://www.typescriptlang.org/docs/handbook/configuring-watch.html)
Что дальше
----------
Команда разработчиков продолжает разработку TypeScript 4.9 и в начале ноября планирует выпустить окончательный релиз. Ждём!
А пока что можно установить себе бета-версию и попробовать новые фичи:
```
npm install -D typescript@beta
```
[Следить за планом итераций TypeScript 4.9](https://github.com/microsoft/TypeScript/issues/50457).
[Почитать про другие изменения бета-версии](https://devblogs.microsoft.com/typescript/announcing-typescript-4-9-beta/). | https://habr.com/ru/post/695900/ | null | ru | null |
# VAX — инструмент для визуального программирования, или как написать SQL мышкой
Я хочу рассказать про созданный мною [web редактор для «визуального программирования»](https://aveic.github.io/vax/) и его историю создания.
Есть у нас отдел, занимающийся претензионной деятельностью с Почтой России. Ребята ищут потерянные/не оплаченные/не доставленные отправления. В сухом остатке для разработчиков эта задача сводилась к написанию очень большого количества разнообразных и огромных (>150 строк) SQL запросов на диалекте PostgreSQL, которые ОЧЕНЬ часто менялись и дополнялись в силу активного появления новых гипотез, а также поступления новых сведений о заказах.
Естественно, нам, как программистам, это дело очень быстро надоело, и сразу захотелось предложить ~~отстать от нас~~ какой-то визуальный инструмент конструирования фильтров, которые в итоге транслируются в SQL. Сначала захотели налепить просто много формочек с кучей «инпутов», но идея быстро провалилась, т.к. было понятно, что все фильтры надо уметь как-то «композиционировать» (compose): объединять в группы, пересекать с разными условиями И, ИЛИ, параметризовать и прочее. И даже простейший реально используемый фильтр начинал выглядеть ужасно. Плюс сбоку закрадывалась мысль, что в принципе данные фильтры являются частным вариантом просто общего сборщика SQL, и вообще, раз уж дошло дело до «визуального программирования», то можно постараться полностью абстрагироваться от предметной области.
И тут, как в фильме «Проблеск гениальности» («Flash of Genius»), у меня перед глазами всплыла картина визуального редактора схем (blueprints) из UE4 (Unreal Engine 4), с помощью которых персонажи запускали файрболы в своих врагов:
Прибежав в тот же вечер домой, я взял первую попавшуюся JavaScript библиотеку, умеющую рисовать красивые прямоугольники и сложные линии — ей оказалась Raphaël от нашего соотечественника [DmitryBaranovskiy](https://habr.com/ru/users/dmitrybaranovskiy/). Нарисовав пару прямоугольников и подёргав их с помощью библиотечных drag-and-drop, я сразу написал автору библиотеки с вопросом поддерживает ли он её. И не дождавшись ответа (до сих пор), я в ту же ночь наплодил более 1000 строк кода на JavaScript, и моя мечта на глазах почти стала явью! Но предстояло ещё много работы.
В итоге, что же захотелось сделать:
* Красивый и удобный редактор в вебе, который предоставляет средства для манипуляции и связывания «узлов» разных типов, которые описываются в доменной схеме, передающейся редактору при инициализации. Тем самым сделать редактор независимым от предметной области.
* Возможность сериализации ацикличного графа пользователя в древовидную структуру, которую очень легко разбирать (parse) (например JSON) и интерпретировать на любом языке.
* Предоставить удобный формат для описания типов и компонентов предметной области.
* Придумать богатую систему типов и ограничений, которая поможет пользователю создавать графы, корректные с точки зрения предметной области.
* Дать возможность пользователю создавать свои компоненты из комбинаций существующих.
В итоге вот что получилось:
Видно, что чертёж (blueprint) состоит из узлов (nodes), которые являются конкретными экземплярами компонентов (component), описанных в схеме предметной области (schema). Узлы соединяют проводами (wires). Провод всегда идёт от выхода (output) одного узла к входу (input) другого (и наоборот). Из одного выхода может идти много проводов, но на вход можно привязать только один.
Все входы и выходы имеют тип, и соответственно накладывают ограничения на возможные связи. Например, возьмём следующую систему типов:
```
types:
# Всегда есть тип Any, который супер-родитель всех типов
Scalar:
Numeric:
extends: Scalar
String:
extends: Scalar
List:
typeParams: [A]
```
Таким образом можно выход типа *Numeric* связать с входом типа Scalar, но не наоборот. Для параметризованных типов вроде *List* подразумевается ковариативность, т.е. *List[String]* можно передать в *List[Scalar]*, но не наоборот. Плюс всегда присутствует супер тип *Any*, наследником которого являются все остальные типы.
У узлов также могу присутствовать атрибуты, которые не настраиваются с помощью проводов, а пользователь сам вводит в них значения. Для этого существуют концепция valuePicker-ов, с помощью которых можно задавать свой интерфейс ввода значений атрибутов. Из коробки есть просто текстовый инпут и возможность выбора из заранее определённого набора констант.
Также узлы бывают параметризованы по типам. Например, дан компонент:
```
IfThenElse:
typeParams: [T]
in:
C: Boolean
out:
onTrue: @T
onFalse: @T
```
При создании узла на базе компонента *IfThenElse* редактор попросит нас указать тип T и подставит его во все места с [T](https://habr.com/ru/users/t/):
Типы входов и выходов также помогают пользователю при проектировании. Если вы потянете проводок из выхода с типом *Numeric* и отпустите мышку, то вылезет окно создания компонентов, отфильтрованных таким образом, что там останутся только те, вход которых совместим (conforms) с типом *Numeric*. И даже автоматически привяжется проводок.
Заняло всё это примерно чистых тройку человеко-недель, растянутых на добрых 5-6 месяцев. И ещё спустя полгода появились силы что-то задокументировать и заявить об этом миру.
Итак, господа, настало время творить! Возьмём самый нереальный случай, когда вам надо предоставить «не техническому» пользователю возможность визуально программировать процесс складывания чисел. Мы пониманием, что нам нужен всего лишь один тип *Numeric* и пару компонентов: возможность задать число (*Literal*) и возможность сложить два таких числа (*Plus*). Далее приведён пример схемы данной предметной области: (все примеры схем описаны в формате YAML для наглядности, в реальности же вам надо будет передавать нативные javascript объекты):
```
types:
# Всегда есть тип Any, который супер-родитель всех типов
Numeric:
color: "#fff"
components:
Literal: # Название компонента
attrs: # Атрибуты
V: Numeric
out: # Исходящие сокеты
O: Numeric
Plus:
in: # Входящие сокеты
A: Numeric
B: Numeric
out:
O: Numeric
```
Пример собранного редактора с данной схемой и простым графом можно посмотреть [тут](https://aveic.github.io/vax/examples/simple/).
Поиграйтесь! Нажмите *X* для создания нового элемента, удалите элемент двойным кликом. Соедините узлы проводками, выделите их все и скопируйте и вставьте через *Ctrl+C* и *Ctrl+V*. Потом выделите все *Ctrl+A* и удалите с помощью *Delete*. Ведь всегда можно сделать Undo, прибегнув к *Ctrl+Z*!
Теперь допустим, наш нехитрый пользователь собрал следующий граф:
Если мы попросим редактор сохранить наш граф в дерево, то получим:
```
[
{
"id": 8,
"c": "Plus",
"links": {
"A": {
"id": 2,
"c": "Literal",
"a": {
"V": "2"
},
"links": {},
"out": "O"
},
"B": {
"id": 5,
"c": "Literal",
"a": {
"V": "2"
},
"links": {},
"out": "O"
}
}
}
]
```
Как видим нам тут пришло дерево, которое очень легко рекурсивно обойти и получить какой-то результат. Допустим, языком нашего бэкэнда является тоже JavaScript (хотя может быть любой).
Пишем тривиальный код:
```
function walk(node) {
switch (node.c) {
case 'Literal':
return parseFloat(node.a.V);
case 'Plus':
return walk(node.links.A) + walk(node.links.B);
default:
throw new Error("Unsupported node component: " + node.component);
}
}
walk(tree);
```
Если мы прогуляемся такой функцией по вышеуказанному дереву, то получим 2+2=4. Вуаля!
Очень приятным бонусом является возможность у пользователя определять свои «функции», объединяя существующие компоненты.
Например, даже имея такую скудную доменную область, где можно просто складывать числа, пользователь может определить свой компонент, который будет умножать заданное число на три:
Теперь у нас появилась пользовательская функция *x3*:
Которой можно воспользоваться, как новым компонентом:
При этом на backend можно послать дерево, где все пользовательские функции развёрнуты (inlined), и разработчик даже не будет знать, что некоторые узлы были в составе пользовательской функции. Получается, что пользователи сами могу обогащать свой язык проектирования при должных фантазии и упорстве.
Вернёмся же к нашему первому примитивному примеру складывания чисел. Не смотря на то, что процессор это интегральное устройство, которое только и делает, что складывает — визуально программировать конечному пользователю на уровне сложения чисел будет не очень весело. Нужны более экспрессивные и богатые конструкции!
Возьмём к примеру замечательный язык SQL. Если присмотреться, то любой SQL запрос на самом деле очень легко раскладывается в дерево (этим и занимается первым делом БД, когда получает ваш запрос). Понаписав достаточное количество типов и компонентов можно получить [нечто уже более устрашающее](https://aveic.github.io/vax/examples/sql/):
**P.S. Если какой-то из примеров не открывается...**
Возможно это связано с тем, что вы уже попытались сохранить пользовательскую функцию для одной из схем. А так как по умолчанию (но можно и нужно определять свои обработчики) все пользовательские функции хранятся в *localStorage*, то может возникнуть ситуация, когда редактор попытается загрузить компоненты или типы, не описанные в текущей схеме.
Для этого просто очистите текущий *localStorage* с помощью:
```
localStorage.clear()
```
К сожалению, демонстрацию превращения данного графа в реальный SQL провести не получится, т.к. она сильно завязана на наш проект. Но в реальности это собирается в следующий SQL:
```
SELECT
COUNT(o.id) AS cnt
, (o.created_at)::DATE AS "Дата"
FROM tbl_order AS o
WHERE o.created_at BETWEEN '2017-1-1'::DATE AND CURRENT_DATE
GROUP BY (o.created_at)::DATE
HAVING ( COUNT(o.id) ) > ( 100 )
ORDER BY (o.created_at)::DATE ASC
```
Который сразу же исполняется и отдаёт готовый отчёт в формате Excel. Переведя данный SQL на человечий, получаем:
Показать количество загруженных заказов за каждую день в хронологическом порядке, начинания с 1 января 2017 года, выкидывания дни, где загрузили меньше чем 100 заказов. Вполне себе реальный отчёт для бизнеса!
Схему в формате JSON для данного примера можно посмотреть [тут](https://aveic.github.io/vax/examples/sql/schema.js).
Я не буду в статье приводить полное описание системы типов и компонентов, за этим отправляю в [соответствующий раздел документации](https://aveic.github.io/vax/schema.html). Но для подогрева интереса лишь немного «вброшу», что можно писать вот так (немного косячит подсветка вычурного синтаксиса YAML):
```
Plus:
typeParams: [T]
typeBounds: {T: {<: Expr}} # Параметризованный тип 'T' ограничен сверху типом 'Expr',
# что означает, что нам надо сюда передать наследник типа 'Expr'
in:
A: @T
B: @T
out:
O: @T
```
Это как если бы вы в Scala объявили функцию:
```
def Plus[T <: Expr](A: T, B: T): T = A + B
```
В итоге, подготовив достаточное количество компонентов, и придумав хорошую систему типов (и написав ~~много~~ немного backend кода для обхода деревьев) мы ~~сбагрили~~ дали возможность пользователю составлять свои ad-hoc отчёты на базе SQL. Немного расширив доменную область, мы сильно упростили исходную задачу с фильтрами для поиска проблемных заказов, описанную в начале статьи. А самое главное дали бизнесу возможность самостоятельно тестировать свои гипотезы без привлечения разработчиков. Теперь правда, приходится обучать и писать новые компоненты, но это куда более приятное занятие! Надеюсь, что на SQL и фильтрах дело не остановится, и мы воспользуемся этим инструментом в другим областях проекта.
Самое главное, что я с радостью передаю этот инструмент в общественное достояние на [GitHub](https://github.com/aveic/vax) под лицензией MIT.
**Кому интересно, есть идеи/задачи по дальнейшему развитию инструмента:**
* Более удобная навигация по компонентам в схеме + их документация для пользователя
* Сокеты-атрибуты (как в UE4)
* Возможность определять атрибуты в пользовательских функциях.
* Режим read-only для отображения схем
* Узлы кастомной формы (как в UE4), а не только прямоугольники
* Ускорение и оптимизация для работы с большим количеством элементов
* Интернационализация
* Экспорт картинки в SVG/PNG
* You name it!
Будет круто, если кому-то захочется воспользоваться этим инструментом на практике и поделиться своим опытом.
**P.S.** Ещё круче будет, если кто-то присоединится к разработке инструмента!
**P.P.S.** Я проводил презентацию инструмента в компании с помощью [данного документа](https://github.com/aveic/vax/blob/master/docs/vax.pdf). | https://habr.com/ru/post/333750/ | null | ru | null |
# Делаем простой гидроакустический модем
### Привет, глубокоуважаемые!
В этой статье, по многочисленным просьбам мы расскажем как сделать простейший гидроакустический модем: немного цифровой обработки сигналов, немного программирования, немного самодельных печатных плат и капля практической гидрологии.
Всем заинтересованным — милости просим под кат, в реверберирующий мир подводной связи!
А вот релевантная картинка, для привлечения внимания:
> «В конечном счете смысл нашего существования — тратить энергию… И по возможности, знаете ли, так, чтобы и самому было интересно, и другим полезно.»
>
> (С) АБС, «Полдень, XXII век»
### Для экономии вашего времени — краткое содержание
* Гидроакустические модемы пока не продают на Aliexpress
* Есть простой и нетребовательный к вычислительным ресурсам метод детектирования тона, частота которого в 4 раза меньше частоты дискретизации; Для реализации хватит и Arduino
* [Пример кода](https://github.com/AlekUnderwater/SimpleUnderwaterAcousticModem/tree/master/SRC) для PC лежит на GitHub
* Приемную и передающие антенны делаем из пьезопищалок по 10 р штука
* Покупаем (или делаем сами) платку усилителя на TDA2030 на Ali за 50 рублей
* Делаем ЛУТ-ом предусилитель, с суммарной стоимостью ~100 рублей
* Подключаем и идем на водоем
* Радуемся
### Мотивационная прелюдия
Сейчас вы можете купить на Aliexpress или eBay практически все, что угодно. Особенно много всякого разного для самостоятельного изготовления чего-либо электронного на основе Arduino. Вы можете сделать (если просто купить неинтересно) мильен-стопервую метеостанцию с подключением к интернет, автоматическую кормушку для кота, контроллер домашней пивоварни, но пока еще вы не можете купить гидроакустический модем, конструктор для его изготовления или хотя бы модуль для адруино. Ну и хорошо! И не надо — сейчас мы расскажем как его сделать, а еще расскажем как он работает.
Мы всей лабораторией долго думали, что можно предложить любителям для самостоятельного изготовления. Что-нибудь очень простое, собрать которое под силу и школьнику, из ~~палки и веревки~~ того, что есть под рукой у каждого, но в то же время обязательно представляющее хотя бы минимальную практическую или учебную ценность.
Что-нибудь обещающее долгое и увлекательное совершенствование, то, что в последствие можно перенести даже на ардуино~~, будь оно неладно~~.
Если подходить к вопросу материалистически, то нам хотелось предложить подробный туториал для изготовления некоего простого устройства, которое было бы более-менее в состоянии передавать данные в мелководном водоеме (мелководный гидроакустический канал — наиболее сложный), подразумевало бы максимум изготовление печатной платы при помощи ЛУТ, с общей стоимостью, не превышающей на минималочках пары-тройки сотен рублей.
### Что мы будем делать сегодня?
* вспомним, как сделать подходящую гидроакустическую антенну и изготовим парочку;
* одну из антенн подключим к ПК через усилитель на TDA за ~50 рублей и получим передатчик;
* для второй сделаем при помощи ЛУТ предусилитель за ~100 рублей;
* напишем ~~(я уже все написал и положил на Git)~~ простой модем на C# и испытаем все на ближайшем водоеме;
### Что нам для этого понадобится?
* два пьезоэлемента. Например, [от часов или открытки](https://www.aliexpress.com/item/5PCS-LOT-15cm-cable-length-diameter-35mm-Piezo-Ceramic-Element/32887402292.html?spm=2114.search0104.3.51.2fa41c2eDCvl13&ws_ab_test=searchweb0_0,searchweb201602_1_10065_10068_10890_319_10546_317_10548_10696_453_10084_454_10083_10618_10307_537_536_10059_10884_10887_321_322_10915_10103_10910,searchweb201603_52,ppcSwitch_0&algo_expid=fc0df690-2647-4172-8edc-978e564b3ec7-7&algo_pvid=fc0df690-2647-4172-8edc-978e564b3ec7&transAbTest=ae803_5);
* кабель RG-174/U (или аналогичный) ~5 метров;
* безуксусный герметик;
* водостойки лак;
* фольгированный текстолит, в общей сложности примерно 100x200 мм;
* усилитель на TDA2030 (например, [такой](https://www.aliexpress.com/item/1pcs-TDA2030A-Module-Single-Power-Supply-Audio-Amplifier-Board-Module/32847983961.html?tt=sns_none&aff_platform=default&cpt=1557766052396&sk=XXxRqxY&aff_trace_key=24a5a2a3375a462ebee4006e2341e3bb-1557766052396-09983-XXxRqxY&terminal_id=6eb28f235e794d9897c6710be47d8866), за 50 рублей);
* [комплектующие](https://github.com/AlekUnderwater/SimpleUnderwaterAcousticModem/blob/master/Preamplifier_board/BOM.xlsx) для предусилителя
### Как оно работает?
Вся идея простейшего модема построена на, опять же, простейшем (совпадение?) детекторе определенного тона, про который, я к своему стыду не слышал. Рассказал мне про него совершенно невзначай [andrey\_9999a](https://habr.com/ru/users/andrey_9999a/). Он, кстати, сделал и плату предусилителя.
В связи с этим мне вспомнилась цитата из книги Леонарда Сасскинда «Битва при черной дыре»:
> «Как ценитель вина, я более или менее уверен, что даже с закрытыми глазами смогу отличить красное от белого. Еще более надежно я отличу вино от пива. Но вот дальше вкус меня подведет.»
>
>
Могу сказать про себя, что как заправский электронщик я более или менее уверен, что точно смогу спаять два толстых провода. Еще более надежно я отличу горячий паяльник от холодного даже с закрытыми глазами, но вот дальше навык меня подведет. Поэтому все, что касается разработки и изготовления плат — это работа моих товарищей и коллег [andrey\_9999a](https://habr.com/ru/users/andrey_9999a/) и [StDmitriev](https://habr.com/ru/users/stdmitriev/).
Итак, вернемся к детектору. Он является упрощенным частным случаем вычисления интеграла Фурье:
В случае цифрового сигнала, для вычисления амплитуды произвольной гармоники потребуется выполнить дискретное преобразование Фурье, для Ардуины это тяжеловато, но хитрость состоит в том, что если взять в качестве несущей частоты *Fc* такую, что она будет ровно в 4 раза меньше частоты дискретизации *Fs*, то амплитуду этой гармоники можно вычислять демонически проще.
В этом случае *dt = 2π\*(Fs/4)/Fs = π/2*, и на период несущей приходится всего 4 сэмпла:
Если все сдвинуть на *π/4* то сэмплы будут принимать только два значения: √2/2 и -√2/2, для простоты оставим только знаки — **«+» и «-»**.
Суть же метода состоит в том, что синусную фазу мы представляем как последовательность знаков **«+» «+» «-» «-»**, а косинусную как **«+» «-» «-» «+»**.
Пусть входной сигнал лежит в буфере *sn*, у нас есть два кольцевых буфера усреднения для синусной и косинусной фазы — *bs* и *bc* размером *N*. Указатели головы и хвоста у них общие — *bH* и *bT*. В начальный момент времени *bH = N-1, bT = 0*. Счетчик циклов усреденения *C = 0*.
Берем из входного буфера по 4 сэмпла и складываем согласно последовательностям знаков.
**Пример кода**
`a = sn(i)
bs(bH) = a
bc(bH) = a
s1 = s1 + a - bs(bT)
s2 = s2 + a - bc(bT)
bH = (bH + 1) % N
bT = (bT + 1) % N
a = sn(i+1)
bs(bH) = a
bc(bH) = -a
s1 = s1 + a - bs(bT)
s2 = s2 - a - bc(bT)
bH = (bH + 1) % N
bT = (bT + 1) % N
a = sn(i+2)
bs(bH) = -a
bc(bH) = -a
s1 = s1 - a - bs(bT)
s2 = s2 - a - bc(bT)
bH = (bH + 1) % N
bT = (bT + 1) % N
a = sn(i+3)
bs(bH) = -a
bc(bH) = a
s1 = s1 - a - bs(bT)
s2 = s2 + a - bc(bT)
bH = (bH + 1) % N
bT = (bT + 1) % N`
После каждой обработанной четверки сэмплов проверяем счетчик циклов усреднения и если он перевалил за *N*, то вычисляем амплитуду *cA* несущей:
```
if ++cycle >= N
cA = sqrt(s1 * s1 + s2 * s2)
cycle = 0
end
```
Вот так это выглядит на идеальном сигнале:
Синим показан сам сигнал, красным — значения амлитуды несущей (все приведено к диапазону -1..1). В данном случае *N=2* т.к. нет никаких шумов и все и так отлично работает.
Теперь добавим немного белого шума и посмотрим, как на это отреагирует наш детектор:
Я добавил белого шума таким образом, чтобы соотношение сигнал-шум было равно 0 дБ. На рисунке выше синим показан зашумленный сигнал, зеленым — исходный, а красным — значение амплитуды. В этом случае детектор при *N=2* уже ничего не задетектировал, и минимальное N при котором он исправно работет равно 32. Т.е. размер окна обработки в сэмплах составил *32\*4 = 128* сэмплов.
То есть, теперь мы можем анализировать входной сигнал и оценивать некий параметр, который количественно показывает наличие частоты, в четыре раза меньше частоты дискретизации. Если задаться неким пороговым значением для этого параметра, то все можно бинаризовать, и говоря по-простому, мы сможем дать ответ на вопрос: присутствует ли заданный тон во входном сигнале или нет?
Это очень хорошо, но нам нужно передавать биты, а биты могут принимать два значения.
Реализовать систему с двумя сигнальными состояниями при помощи одного — так себе идея, поэтому мы *не будем* кодировать одно из состояний тишиной (паузой). Это бы сильно затруднило детектирование: нужно было бы как-то выделять начало посылки, придумывать как оформить ее конец и т.д.
Вместо этого «1» и «0» мы будем кодировать импульсами разной длины, между битами наличествует т.н. защитный интервал — ведь нам же еще нужно бороться с многолучевым распространением и реверберацией. Говоря простым языком, защитный интервал — это то место (время), где затухнут все отражения предшествующего бита, все послезвучия и эхо.
Забегая вперед, примем к сведению, что при такой структуре сигнала алгоритм работы приемника очень сильно упрощается: ждем когда появился тон, засекаем начало, ждем, когда тон пропал и опять засекаем время — если полученное время больше похоже по длине на «1» то, наверное мы приняли бит со значением «1», если больше похоже на «0» — то видимо мы приняли бит, со значением «0».
В общем, можно сказать, что это некий вариант морзянки.
### Софтовая часть модема
Для нетерпеливых — [пример лежит на GitHub](https://github.com/AlekUnderwater/SimpleUnderwaterAcousticModem). Написан на скорую руку на C# (потому что для ПК я пишу на нем и мне просто так удобнее и быстрее).
Для воспроизведения и захвата звука с микрофонного входа используется замечательная библиотека [NAudio](https://github.com/naudio/NAudio).
Вся логика модема находится в классе [SUAModem](https://github.com/AlekUnderwater/SimpleUnderwaterAcousticModem/blob/master/SRC/C%23/SUAModem.cs) (Simple Underwater Acoustic Modem).
В конструктор передаются следующие параметры:
double sRateHz — частота дискретизации в Герцах;
int wSize — размер окна обработки в сэмплах;
int oneMultiplier — сколько «окон» длится бит со значением «1»
int zeroMultiplier — сколько «окон» длится бит со значением «0»
double eThreshold — порог, скажем о нем позже
Для формирования сигнала из массива байт есть метод ModulateData(byte[] data), который возвращает массив 16-ти битных знаковых сэмплов.
**public short[] ModulateData(byte[] data)**
```
public short[] ModulateData(byte[] data)
{
double alpha = 0;
double phase = 0;
List samples = new List();
BitArray bits = new BitArray(data);
for (int i = 0; i < bits.Length; i++)
{
int sLim = (bits[i]) ? oneDurationSmp : zeroDurationSmp;
alpha = 0;
phase = 0;
for (int sIdx = 0; sIdx <= sLim; sIdx++)
{
alpha = Math.Sin(phase);
phase += delta;
if (phase >= alimit)
phase -= alimit;
samples.Add(Convert.ToInt16(alpha \* short.MaxValue));
}
samples.AddRange(new short[defenseIntervalSmp]);
}
return samples.ToArray();
}
```
В основном цикле по передаваемым битам происходит заполнение списка samples. В зависимсоти от текущего передаваемого бита устанавливается длина sLim формируемого сигнала в сэмплах. После каждого бита добавляется защитный интервал.
**Конечно...**
Многие могут заметить, что при генерации сигнала можно было бы обойтись и без функции синуса, но данный пример позволяет, изменив соотвествующим образом значение delta, изменить и частоту генерируемого тона.
Для генерации тона с частотой  при заданной частоте дискретизации  соответствующее значение  вычисляется просто:
Для формирования и излучения сигнала есть метод TransmitData(byte[] data), который внутри себя вызывает ModulateData:
**public double TransmitData(byte[] data)**
```
public double TransmitData(byte[] data)
{
var samples = ModulateData(data);
double txTime = ((double)samples.Length) / SampleRateHz;
var rawBytes = new byte[samples.Length * 2];
for (int i = 0; i < samples.Length; i++)
{
var bts = BitConverter.GetBytes(samples[i]);
rawBytes[i * 2] = bts[0];
rawBytes[i * 2 + 1] = bts[1];
}
using (var ms = new MemoryStream(rawBytes))
{
using (var rs = new RawSourceWaveStream(ms, new WaveFormat(Convert.ToInt32(SampleRateHz), 16, 1)))
{
using (var wo = new WaveOutEvent())
{
wo.Init(rs);
wo.Play();
while (wo.PlaybackState == PlaybackState.Playing)
{
Thread.SpinWait(1);
}
}
rs.Close();
}
ms.Close();
}
return txTime;
}
```
О принятии очередного байта класс SUAModem сообщает при помощи события DataReceivedEventHandler.
Входные сэмплы послупают в анализ при помощи метода ProcessInputSignal(short[] data), где записываются в кольцевой буфер ring. Анализ происходит в отдельном потоке, в методе Receiver.
А сам приемник живет в методе Receive:
**private void Receive()**
```
private void Receive()
int a;
while (rCnt >= 4)
{
a = ring[rRPos];
rRPos = (rRPos + 1) % rSize;
rCnt--;
dRing1[rHead] = a;
dRing2[rHead] = a;
s1 += a - dRing1[rTail];
s2 += a - dRing2[rTail];
rHead = (rHead + 1) % windowSize;
rTail = (rTail + 1) % windowSize;
a = ring[rRPos];
rRPos = (rRPos + 1) % rSize;
rCnt--;
dRing1[rHead] = a;
dRing2[rHead] = -a;
s1 += a - dRing1[rTail];
s2 += -a - dRing2[rTail];
rHead = (rHead + 1) % windowSize;
rTail = (rTail + 1) % windowSize;
a = ring[rRPos];
rRPos = (rRPos + 1) % rSize;
rCnt--;
dRing1[rHead] = -a;
dRing2[rHead] = -a;
s1 += -a - dRing1[rTail];
s2 += -a - dRing2[rTail];
rHead = (rHead + 1) % windowSize;
rTail = (rTail + 1) % windowSize;
a = ring[rRPos];
rRPos = (rRPos + 1) % rSize;
rCnt--;
dRing1[rHead] = -a;
dRing2[rHead] = a;
s1 += -a - dRing1[rTail];
s2 += a - dRing2[rTail];
rHead = (rHead + 1) % windowSize;
rTail = (rTail + 1) % windowSize;
if (++cycle >= windowSize)
{
cycle = 0;
currentEnergy = Math.Sqrt(s1 * s1 + s2 * s2) / windowSize;
double de = currentEnergy - prevEnergy;
#region analysis
if (skip > 0)
skip -= windowSize * 4;
else
{
if (isRise)
{
if (de > -Threshold)
{
riseSmp += windowSize * 4;
}
else
{
// analyse symbol
isRise = false;
double oneDiff = Math.Abs(oneDurationSmp - riseSmp);
double zeroDiff = Math.Abs(zeroDurationSmp - riseSmp);
if (oneDiff > zeroDiff)
{
// Mostly likely "0"
AddBit(false);
}
else
{
// Mostly likely "1"
AddBit(true);
}
samplesSinceLastBit = 0;
skip = defenseIntervalSmp / 2;
}
}
else
{
if (de > Threshold)
{
isRise = true;
riseSmp = windowSize * 4;
}
}
}
#endregion
prevEnergy = currentEnergy;
if (bPos > 0)
{
samplesSinceLastBit += 4 * windowSize;
if (samplesSinceLastBit >= defenseIntervalSmp * 2 + zeroDurationSmp + oneDurationSmp)
{
DiscardBits();
}
}
}
}
}
```
Из кода видно, что анализ ведется по 4 сэмпла, при желании можно сохранять состояние и вести обработку и по одному сэмплу, что будет полезно при переносе на какой-нибудь немощный МК.
По мере поступления данных вычисляется значение амлитуды s на частоте sRateHz/4. Вычисляется разница между предыдущим и текущим значением амплитуды и затем сравнивается с заданным порогом, подобранным экспериментально. Пример позволяет в реальном времени этот порог менять.
Резкое увеличение амплитуды свидетельствует о начале «бита», резкий (несколько менее резкий — из-за реверберации) спад — о завершении «бита».
После приема очередного бита отрабатываем защитный интервал — пропускаем заданное количество сэмплов — в них всякие эхо, они нам будут только мешать.
### Железная часть модема
Итак, со структурой сигнала все понятно, как его принимать тоже ясно. Дело за малым — научиться излучать сигнал в воду и принимать его из воды.
Если у вас еще нет гидроакустических антенн, то самое время их сделать по [нашему предыдущему туториалу](https://habr.com/ru/post/431302/).
У меня они остались с того раза, так что я этот шаг пропускаю.
Ту антенну, которая предназначена для передачи мы подключаем к [плате усилителя с алиэкспресс](https://www.aliexpress.com/item/1pcs-TDA2030A-Module-Single-Power-Supply-Audio-Amplifier-Board-Module/32847983961.html?tt=sns_none&aff_platform=default&cpt=1557765605290&sk=XXxRqxY&aff_trace_key=5b7cbf3c89fc4d6fbe6aa2e870630181-1557765605290-02601-XXxRqxY&terminal_id=6eb28f235e794d9897c6710be47d8866). Для нескольких десятков метров (может даже для сотни) нам этого вполне хватит. Никаких хитростей тут нет — выход звуковой карты ноутбука идет на вход усилителя, который питается от свинцового АКБ 12 вольт 4 Ач. На выход подключена наша гидроакустическая передающая антенна из пьезопищалки. В моем случае это выглядит вот так:
На фото выше, на экране есть небольшой спойлер следующей статьи. В следующий раз на этих же железках мы снова будем пытаться передавать «видео» звуком через воду, но совершенно иным способом, чем в [прошлый раз](https://habr.com/ru/post/408871/).
С приемной антенной несколько сложнее. Хоть пьезопищалки и очень чувствительны, все же этого недостаточно. Нам придется собрать плату предусилителя с фильтром на полосу 5-35 кГц.
Коэффициент усиления мы берем 1000.
Схема, дизайн печатной платы и список компонентов предусилителя лежит у нас на GitHub: [схема](https://github.com/AlekUnderwater/SimpleUnderwaterAcousticModem/blob/master/Preamplifier_board/piezo_preamp_1000_5-35kHz_schematic.pdf), дорожки — [верхний слой](https://github.com/AlekUnderwater/SimpleUnderwaterAcousticModem/blob/master/Preamplifier_board/Top_70x25_mm.bmp) и [нижний слой](https://github.com/AlekUnderwater/SimpleUnderwaterAcousticModem/blob/master/Preamplifier_board/Bottom_70x25_mm.bmp), [BOM](https://github.com/AlekUnderwater/SimpleUnderwaterAcousticModem/blob/master/Preamplifier_board/BOM.xlsx).
[Технология ЛУТ](https://habr.com/ru/search/?q=%D0%9B%D0%A3%D0%A2#h) обсуждалась стотыщмильенов раз, но дайте же и нам внести свою лепту.
**Фото технологического процесса**
Итак, берем подходящий журнал, у нас под рукой оказался только этот:
Берем оттуда пару страниц и печатаем на них слои при помощи лазерного принтера.
Совмещаем при помощи иголочек и склеиваем по одной стороне, как показано на фото:
Перед применением утюга смачиваем тонер изопропиловым спиртом:
Утюжим через сложенный вчетверо лист А4:
Размачиваем теплой водой под краном:
И отмываем остатки бумаги. После чего получаем заготовку, готовую к травлению:
Лишнее отрезаем при помощи ножниц по металлу или кому чем удобнее.
Травим в хлорном железе. Специально для статьи мы развели свежее, оно оказалось настолько забористое что от будущей платы активно идут пузырики:
В результате, после травления и отмывки тонера получаем такой полуфабрикат:
После напайки компонентов и отмывки плата выгладит вот так.
А так выглядит приемная часть в сборе. Питание осуществляется от такого же свинцового АКБ 12 вольт:
**Небольшой дисклеймер по поводу фильтра**
Если читатель захочет изменить полосу, то предлагаем пересчитать фильтр 8-ого порядка, собранный на дешевом 4-х канальном операционнике TL084C (DA2 на [схеме](https://github.com/AlekUnderwater/SimpleUnderwaterAcousticModem/blob/master/Preamplifier_board/piezo_preamp_1000_5-35kHz_schematic.pdf)), резисторах R10-R13, R15-R23 и конденсаторах C5-C8, C11, C12, C14 и С15.
На всякий случай приведем здесь АЧХ текущей реализации фильтра:
А вот еще [проект](https://github.com/AlekUnderwater/SimpleUnderwaterAcousticModem/blob/master/Preamplifier_board/filter.sch) для этого фильтра, созданный в приложении [Qucs](http://qucs.sourceforge.net/)
### Опыты и испытания
Для подключения к ноутбуку используем обычный Jack 3.5 мм, самый кончик — сигнал, средний — не подключен, земля — к земле ~~прах к праху~~. Все усиления и любые эффекты микрофона нужно отключить, а громкостью придется поиграться, чтобы достичь оптимального уровня. Зашкал должен происходить при касании подключенной к предусилителю антенны пальцем и легком поглаживании.
Если просто положить одну пьезу на другую без усилителя и предусилителя и подключить их к аудиовходу и выходу, то все работает идеально. Ниже представлен отрезок сигнала и можно даже на глаз определить где какие значения битов:
Синим показан сам сигнал, красным — разница между текущим и предыдущим значениями амплитуды (фронт), зеленым — разница между предыдущим и текущим значениями (спад). Без труда можно «демодулировать» эту часть посылки: 1 0 0 0 1 1 0. Ноль у нас в два раза дольше единицы, а длительность защитного интервала равна длительности нуля.
Далее, также без усилителя и предусилителя опускаем наши антенны в металлический бак, размерами 3х1.5х1.5. У нас такой стоит в лаборатории, и мы завели себе правило, что не занимаемся никакой связью, если она хоть как-то не в состоянии работать в этом баке. Дело в том, что в таком замкнутом объеме энергии особо некуда деваться — звук чудесно и многократно отражается от металлических стенок и в точке приема получается каша. А с учетом того, что мы обычно проверяем готовые девайсы с энергетикой, рассчитанной на тысячи метров, можете представить что там творится.
Например, два наших модема [RedLINE](https://docs.unavlab.com/documentation/RU/RedLINE/RedLine_Specification_ru.html) устойчиво работают в этом баке только на расстоянии не больше двух метров, а два [uWAVE](https://habr.com/ru/post/428367/)-а стабильно работают примерно на 1 метре. При том что первый в открытой воде работает до 8000 метров, а второй — [до километра](https://www.youtube.com/watch?v=Z1bVerVecY0).
Конечно, все коммерческие продукты не используют такие примитивные схемы модуляции, о которой идет речь в статье и устроены гораздо сложнее, но нам сейчас важно понять азы и с пользой поделать что-то руками.
В общем, опускаем антенны в бак на расстояние порядка 50 сантиметров и получаем уже нечто гораздо менее благообразное, чем при непосредственном контакте антенн:
Хотя здесь использован значительно более долгий защитный интервал, все равно видно, что эхо гуляет почти до следующего бита, фронты и особенно спады сильно размыты. Но все еще можно определить содержание сообщения: 1 0 0 0 1 1 0
В обоих случаях я передавал сообщение «123» и эти семь бит принадлежат символу единицы.
Выглядело это примерно так, потом интерфейс был немного переделан
Из скрина выше видно, что при тех настройках, передача сообщения «Hello, [habr](https://habr.com/ru/users/habr/)!!! :-)» состоящее из 19 байт занимает 9.132 секунд, то есть скорость передачи составила 16,6 бит/с. К слову сказать, чтобы модем работал в нашем баке пришлось увеличить защитный интервал так, что скорость передачи упала до ~3 бит/с.
Мы проверяли самоделку в плавательном бассейне, где устойчиво она заработала на 10 метрах.
Еще мы баловались самоделкой на пруду. Я использовал активный гидрофон очень похожий по конструкции на предложенный в статье, только вместо пьезопищалки там применен датчик от парктроника, аккумулятор там смонтирован в катушку, на которую наматывается кабель:
Антенны приемника и передатчика опускались прямо с берега, глубина там резко уходит с 0.5 до 2 метров. В опыте, который показан на фото выше были, как ни странно, самые плохие условия, дистанция там была всего порядка 5 метров — это вообще была первоначальная настройка. Из 20 переданных сообщений по 3 байта, в шести из них было побито по одному байту.
Потом, когда мы подключили приемник ко второму ноутбуку и перенесли на другой берег пруда (дистанция порядка 30 метров) передача проходила значительно лучше — на 40 сообщений размером от 3 до 13 байт было всего пару ошибок.
На следующем фото на карте видны места, где располагались антенны.
### Заключение и дальнейшие изыскания
Как и обещал, за мало рублей мы собрали рабочее устройство. Хоть практическая ценность его сомнительна, но сам процесс изготовления и настройки на водоеме будет очень полезен начинающим. На описанном методе детектирования несущей вполне можно придумать разных простых навигационных систем для любительского применения, а что особенно приятно, вычислительная сложность позволяет реализовать метод на простом микроконтроллере.
Чтобы не быть голословным относительно построения навигационных систем на простых сигналах, взгляните на [интересную работу](https://www.semanticscholar.org/paper/UNDERWATER-ACOUSTIC-POSITIONING-SYSTEMS-BASED-ON-Alcocer-Oliveira/134a4e769a6a64c6f5bc0f0efda9ed2a93893bdb), в которой построили полноценную длиннобазисную навигационную систему. В этой системе определяют положение пингера, который периодически передает свою глубину. Значение глубины при этом кодируется расстоянием между двумя простыми импульсами на определенной частоте. Так что да-да, горшки не боги обжигают, дорогу осилит идущий, терпение и труд, учиться, учиться, учиться — вот это вот все.
Возможно, при наличии времени мы сделаем DIY-проект по позиционированию автономного пингера, излучающего простые сигналы. Нечто подобное, но не DIY мы уже делали на базе наших модемов [uWAVE](https://docs.unavlab.com/documentation/RU/uWAVE/uWAVE_Specification_ru.html), о чем даже попытались [снять видео](https://www.youtube.com/watch?v=UHfTv7TtABU&t=11s). Будет очень интересно услышать ваши мнения на этот счет — очень важно иметь подтверждение, что делаешь что-то не напрасно.
Тем не менее, возвращаясь к основной теме, отметим, что можно было бы улучшить в предложенной схеме:
* сделать вычисление порога адаптивным
* анализировать ширину сигналов автоматически
* попробовать использовать разные длины для разных битовых комбинаций
* прикрутить ~~обожебоже~~ помехоустойчивое кодирование
* перенести все это на ардуино
* громкость и порог приходится долго и нудно подбирать, поэтому хорошо бы добавить в предусилитель АРУ
На этом заседание объявлю закрытым, а если вас заинтересовала тема, вот список наших предыдущих статей:
[Подводный GPS с нуля за год](https://habr.com/ru/post/370083/)
[Подводный GPS на подводном роботе: опыт использования](https://habr.com/ru/post/449072/)
[Мы сделали самый маленький в мире гидроакустический модем](https://habr.com/ru/post/428367/)
[К вопросу о влиянии цианобактерий на речевые функции президента](https://geektimes.ru/post/293681/)
[Делаем простую гидроакустическую антенну из мусора](https://habr.com/ru/post/431302/)
[Сеанс передачи видео звуком через воду с разоблачением](https://habr.com/post/408871/)
[Подводный «GPS» на двух приемопередатчиках](https://habr.com/ru/post/421977/)
[Навигация под водой: пеленгуй не пеленгуй — обречен ты на успех](https://habr.com/ru/post/405845/)
[Подводный GPS: продолжение](https://habr.com/ru/post/403891/)
### P.S.
Как всегда с удовольствием выслушаем замечания и предложения, обоснованную критику и одобряющие возгласы )
### P.P.S.
Железки далеко не убирайте — в следующий раз мы с их помощью будем опять передавать «видео» через воду. | https://habr.com/ru/post/451800/ | null | ru | null |
# folly::fbvector — улучшенный std::vector от Facebook
[Folly](https://github.com/facebook/folly) — это открытая С++ библиотека, разрабатываемая Facebook и используемая им во внутренних проектах. С целью оптимизации расходов памяти и процессорных ресурсов библиотека включает собственные реализации некоторых стандартных контейнеров и алгоритмов. Одной из них является [folly::fbvector](https://github.com/facebook/folly/blob/master/folly/docs/FBVector.md) — замена стандартного вектора (std::vector). Реализация от Facebook полностью совместима с оригинальным интерфейсом std::vector, изменения всегда не-негативны, почти всегда измеримы, часто — существенно, а иногда даже грандиозно влияют на производительность и\или расход памяти. Просто включите заголовочный файл folly/FBVector.h и замените std::vector на folly::fbvector для использования его в своём коде.
#### Пример
```
folly::fbvector numbers({0, 1, 2, 3});
numbers.reserve(10);
for (int i = 4; i < 10; i++) {
numbers.push\_back(i \* 2);
}
assert(numbers[6] == 12);
```
#### Мотивация
std::vector — устоявшаяся абстракция, которую многие используют для динамически-аллоцируемых массивов в С++. Также это самый известный и самый часто используемый контейнер. Тем большим сюрпризом оказывается то, что его стандартная реализация оставляет достаточно много возможностей по улучшению эффективности использования вектора. Этот документ объясняет, как реализация folly::fbvector улучшает некоторые аспекты std::vector. Вы можете воспользоваться тестами из [folly/test/FBVectorTest.cpp](https://github.com/facebook/folly/blob/master/folly/test/FBVectorTest.cpp) чтобы сравнить производительность std::vector и folly::fbvector.
#### Управление памятью
Известно, что std::vector растёт экспоненциально (с константным коэффициентом роста). Важный нюанс в правильном выборе этой константы. Слишком маленькое число приведёт к частым реаллокациям, слишком большое — будет съедать больше памяти, чем реально необходимо. Изначальная реализация Степанова использовала константу 2 (т.е. каждый раз, когда вызов push\_back требовал расширения вектора — его емкость увеличивается вдвое).
Со временем некоторые компиляторы уменьшили эту константу до 1.5, но gcc упорно использует 2. На самом деле можно математически доказать, что константа 2 — строго худшее из всех возможных значений, потому что оно никогда не позволяет переиспользовать ранее выделенную вектором память.
Чтобы понять почему это так — представьте себе вектор размером в n байт, уже полностью заполненный, в который пытаются добавить ещё один элемент. Это приводит, согласно реализации std::vector, к следующим шагам:
1. Выделяется память, размером в 2 \* n байт. Скорее всего, она будет выделена в адресном пространстве ЗА текущим вектором (может быть непосредственно за, может быть через какой-то промежуток).
2. Старый вектор копируется в начало нового.
3. В новый вектор добавляется новый элемент.
4. Старый вектор удаляется.
Когда дело дойдёт до увеличения этого нового вектора — он будет увеличен до 4 \* n, далее — до 8 \* n и т.д. При каждом новом выделении памяти её будет требоваться больше, чем для всех предыдущих векторов, вместе взятых, поскольку на каждом шаге k нам понадобиться (2 ^ k) \* n байт памяти, а это всегда больше суммы (2 ^ (k — 1)) \* n + (2 ^ (k — 2)) \* n… + ((2 ^ 0 )) \* n
Т.е. менеджер памяти никогда не сможет переиспользовать ранее выделенную для вектора память и всегда будет вынужден выделять «новую» память. Вряд ли это действительно то, чего мы хотим. Так вот, любое число, меньшее, чем 2 гарантирует, что на каком-то шаге увеличения ёмкости вектора мы сможем не выделять память в новом адресном пространстве, а переиспользовать уже ранее выделенную на этот вектор память.
График показывает что при константе увеличения ёмкости равной 1.5 (синяя линия) память может быть переиспользована уже послге 4-го шага увеличения вектора, при 1.45 (красная линия) — после третьего, и при 1.3 (чёрная линия) — после второго.
Конечно, график выше делает несколько упрощений по поводу того, как в реальном мире работают аллокаторы памяти, но факт того, что выбранная gcc константа 2 является теоретически худшим случаем, от этого не меняется. fbvector использует константу 1.5. И это не бьёт по производительности на малых размерах векторов, из-за того, как fbvector взаимодействует с jemalloc.
#### Взаимодействие с jemalloc
Практически все современные аллокаторы памяти выделяют память определёнными квантами, выбранными так, чтобы минимизировать накладные расходы на управление памятью и в то же время дать хорошую производительность на малых размерах выделяемых блоков. К примеру, аллокатор может выбирать блоки примерно так: 32, 64, 128,… 4096, затем пропорционально размеру страницы до 1 МБ, затем инкременты по 512 КБ и так далее.
Как обсуждалось выше, std::vector также требует выделения памяти квантами. Размер следующего кванта определяется исходя из текущей ёмкости вектора и константы роста. Таким образом в почти каждый момент времени у нас имеется некоторое количество неиспользуемой в текущий момент времени памяти в конце вектора, и сразу за ним — некоторое количество неиспользуемой памяти в конце блока памяти, выделенного аллокатором. Сам по себе напрашивается вывод о том, что союз аллокатора вектора и общего аллокатора памяти может дать оптимизацию расхода ОЗУ — ведь вектор может попросить у аллокатора блок «идеального» размера, исключив неиспользуемую память в блоке, выделенном аллокатором. Ну и вообще общую стратегию выделения памяти вектором и аллокатором можно заточить лучше, если знать точную реализацию того и другого. Именно это и делает fbvector — он автоматически определяет использование jemalloc и подстраивается под его алгоритмы выделения памяти.
Некоторые аллокаторы памяти не поддерживают in-place реаллокацию (хотя большинство современных всё-же поддерживают). Это результат не слишком удачного дизайна сишной функции realloc(), которая сама решает, переиспользовать ли ей ранее выделенную память, или выделить новую, скопировать туда данные и освободить старую. Этот недостаток контроля выделения памяти сказывается и на операторе new в С++ и на поведении std:allocator. Это серьёзный удар по производительности, поскольку in-place реаллокация, будучи очень дешевой, приводит к значительно менее аггрессивной стратегии роста потребляемой памяти.
#### Реаллокация объектов
Одним из важных вопросов размещения объектов С++ в памяти является то, что по-умолчанию они считаются неперемещаемыми. Перемещаемым считается объект типа, который может быть скопирован в другое место памяти путём побитового копирования и при этом в новом месте объект полностью сохранит свою валидность и целостность. К примеру, int32 является перемещаемым, потому что 4 байта полностью описывают состояние 32-битного знакового числа, если скопировать эти 4 байта в другое место памяти — этот блок памяти может полностью однозначно быть интерпретирован как то же самое число.
Предположение С++ о том, что объекты являются неперемещаемыми вредит всем и делает это лишь ради нескольких спорных моментов архитектуры. Перемещение объекта предполагает выделение памяти под новый объект, вызов его конструктора копирования, уничтожение старого объекта. Это не очень приятно и вообще против здравого смысла. Представьте себе теоретический разговор капитана Пикара и Скептического Инопланетянина:
**Скептический Инопланетянин**: Итак, этот ваш телепорт — как он работает?
**Пикар**: Он берёт человека, дематериализует его в одном месте и материализует в другом
**Скептический Инопланетянин**: Хм… это безопасно?
**Пикар**: Да, правда в первых моделях были мелкие недочёты. Сначала человек просто клонировался, создавался в новом месте. После этого оператор телепорта должен был вручную застрелить оригинал. Спроси О'Браяна, он работал интерном как-раз на этой должности. Не очень элегантная была реализация.
(**прим. переводчика**: видимо, это писалось до внедрения конструкторов перемещения в последних стандартах С++).
На самом деле только часть объектов действительно неперемещаемы:
* Те, в которых есть указатели на внешние объекты
* Те, на которые указывают указатели из других объектов
Объекты первого типа всегда могут быть переделаны с минимальными затратами. Объекты второго типа не должны создаваться оператором new и удаляться оператором delete — они должны быть управляемы умными указателями и никаких проблем не будет.
Перемещаемые объекты весьма интересны для std::vector, поскольку знание о том, как перемещать объекты внутри вектора существенно влияет на эффективность реаллокации вектора этих объектов. Вместо вышеописанного Пикардовского цикла перемещения, объекты можно перемещать простым memcpy или memmove. К примеру, работа с типами вроде vector или vector> может быть значительно быстрее.
Для того, чтобы поддерживать безопасное перемещение объектов, fbvector использует типаж (trait) folly::IsRelocatable, определённый в «folly/Traits.h». По-умолчанию, folly::IsRelocatable::value консервативно возвращает false. Если вы точно знаете, что ваш тип Widget является перемещаемым, вы можете сразу после объявления этого типа дописать:
```
namespace folly {
struct IsRelocatable : boost::true\_type {};
}
```
Если вы не сделаете этого, fbvector не скомпилируется с BOOST\_STATIC\_ASSERT.
#### Дополнительные ограничения
Некоторые улучшения также возможны для «простых» типов (точнее для тех, которые имеют тривиальную операцию присваивания) или для тех типов, которые имеют конструктор, не выбрасывающий исключений (nothrow default constructor). К счастью, эти типажи уже присутствуют в стандарте С++ (ну или в Boost). Суммируя, для работы с fbvector тип Widget должен удовлетворять условию:
```
BOOST_STATIC_ASSERT( IsRelocatable::value && (boost::has_trivial_assign::value || boost::has_nothrow_constructor::value));
```
Эти типажи на самом деле очень близки — достаточно сложно сконструировать класс, который будет удовлетворять одной части условия и нарушить другую (разве что специально очень постараться). fbvector использует эти простые условия для минимизации операций копирования для основных операций с вектором (push\_back, insert, resize).
Для упрощения проверки типа на совместимость с fbvector в Traits.h есть макрос FOLLY\_ASSUME\_FBVECTOR\_COMPATIBLE.
#### Разное
Реализация fbvector сконцентрирована на эффективности использования памяти. В будущем может быть улучшена реализация копирования из-за того, что memcpy не является intrinsic-функцией в gcc и не идеально работает для больших блоков данных. Также возможно улучшение в области взаимодействия с jemalloc.
Удачного вам использования fbvector. | https://habr.com/ru/post/238131/ | null | ru | null |
# Создаем Gatling скрипты с помощью VS Code
***Перевод статьи подготовлен в преддверии старта курса [«Нагрузочное тестирование»](https://otus.pw/OIds/).***
---
Предисловие
-----------
Недавно, благодаря комментарию одного из студентов, изучающих мой курс [Gatling Fundamentals](https://www.udemy.com/course/gatling-fundamentals/), я узнал о том, что вы можете создавать Gatling скрипты с помощью [Visual Studio Code](https://code.visualstudio.com/). Я, честно говоря, понятия не имел, что это возможно, — но был приятно удивлен, обнаружив, насколько хорошо это работает!
В этом посте мы рассмотрим, как настроить вашу среду разработки Gatling скриптов в VS Code. Мы рассмотрим инструменты сборки **Maven** и **SBT**.
Установка Metals
----------------
Первое, что нужно сделать, планируете ли вы работать с Maven или SBT, это установить плагин [Scala Metals](https://marketplace.visualstudio.com/items?itemName=scalameta.metals) внутри VS Code. Этот плагин позволит языковому серверу Scala работать в VS Code и предоставит типичные функции, которые вы ожидаете от современного IDE.
Установите плагин из VS Code самым стандартным способом, перейдя на вкладку `Extensions` и выполнив поиск `Scala` (Metals):
Имея установленный Metals, давайте сначала посмотрим, как запустить Gatling в VS Code с помощью Maven.
Gatling VScode с Maven
----------------------
Во-первых, вам нужно [установить Maven](https://maven.apache.org/download.cgi) — вы можете скачать Maven с официального сайта и следовать инструкциям по установке на его странице.
Затем [установите плагин Maven for Java](https://marketplace.visualstudio.com/items?itemName=vscjava.vscode-maven) внутри VS Code:
По-прежнему внутри VS Code, откройте `Command Pallette (View > Command Pallette)` и выберите Maven: `Update Maven Archetype Catalog`:
Как и следовало ожидать, это обновит каталог доступных архетипов Maven.
Теперь мы хотим создать новый проект Gatling из архетипа Gatling Maven. Для этого сначала откройте `Command Pallette` и выберите `Maven: Create Maven Project`. При выборе архетипа, нажмите `more`. Введите `Gatling`, после чего должен появиться архетип Gatling. Дальше смотрите видео ниже:
Сохраните проект в подходящем месте на вашем компьютере. Затем откройте проект как обычно в VS Code. Возможно, на этом этапе вам придется импортировать сборку. Для этого перейдите на вкладку Metals в VS Code и нажмите `Import Build`:
Это заставит Maven собрать ваш проект.
Теперь самым ординарным способом добавьте свой код Gatling симуляции. Если вы просто следуете моему примеру и вам нужен пример Gatling скрипта, вы можете использовать этот базовый скрипт ниже:
```
package computerdatabase
import io.gatling.core.Predef._
import io.gatling.http.Predef._
import scala.concurrent.duration._
class BasicSimulation extends Simulation {
val httpProtocol = http
.baseUrl("http://computer-database.gatling.io")
// Здесь находится корень для всех относительных URL
.acceptHeader(
"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
// Вот общие заголовки
.acceptEncodingHeader("gzip, deflate")
.acceptLanguageHeader("en-US,en;q=0.5")
.userAgentHeader(
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:16.0) Gecko/20100101 Firefox/16.0"
)
val scn =
scenario("Scenario Name") // A scenario is a chain of requests and pauses
.exec(
http("request_1")
.get("/")
)
.pause(7) // Note that Gatling has recorder real time pauses
setUp(scn.inject(atOnceUsers(1)).protocols(httpProtocol))
}
```
Чтобы запустить скрипт, откройте терминал в VS Code, и введите `mvn gatling:test`. Если вы хотите запустить определенный тестовый сценарий, вы можете вместо этого выполнить
```
mvn gatling:test -Dgatling.simulationClass=computerdatabase.BasicSimulation
```
Советую вам узнать больше о [плагине Gatling Maven](https://gatling.io/docs/current/extensions/maven_plugin/).
Gatling VScode с SBT
--------------------
Если вы предпочитаете запускать и создавать свои Gatling проекты с помощью Scala Build Tool (SBT), я считаю, что проще всего сначала клонировать проект [Gatling SBT Plugin Demo](https://github.com/gatling/gatling-sbt-plugin-demo).
Как только вы клонировали проект, откройте его как обычно в VS Code. Перейдите на вкладку Metals в VS Code и нажмите `Import Build`:
VS Code теперь должен собрать ваш проект Gatling с помощью SBT.
Чтобы запустить все тесты в вашем проекте, откройте терминал и введите `sbt gatling:test`. Или же чтобы запустить конкретный тестовый скрипт, вы можете выполнить команду `sbt gatling:testOnly computerdatabase.BasicSimulation`.
Вы можете узнать больше о [плагине Gatling SBT](https://gatling.io/docs/current/extensions/sbt_plugin/) в его документации.
Резюме
------
В этой статье мы узнали, как использовать Visual Studio Code для создания наших Gatling скриптов. Мы рассмотрели, как создать и запустить Gatling проект с инструментами сборки Maven и SBT.
Несмотря на то, что [IntelliJ IDEA](https://www.jetbrains.com/idea/) остается моей предпочтительной средой разработки для разработки кода Scala и Gatling, здорово иметь возможность использовать и более популярный VS Code!
---
Узнать подробнее о курсе [«Нагрузочное тестирование»](https://otus.pw/j0bA/)
--- | https://habr.com/ru/post/509854/ | null | ru | null |
# Один фаервол для IPv4 и IPv6 (iptables и ip6tables)
После [настройки IPv6](http://habrahabr.ru/blogs/sysadm/82397/) появляется задача настройки фаервола для нового протокола. Ниже я предлагаю свой скрипт, который позволяет настроить фаервол сразу для IPv4 и IPv6. Хотя общих правил для обоих фаерволов получилось не так уж и много, мне всё-таки удобнее править один общий файл, чем два разных.
Рассматривать будем самую обычную сеть с одним подключением к интернету и одной локальной сетью за фаерволом. Для локальной сети в IPv4 нужно сделать NAT, в IPv6 нужно маршрутизировать и фильтровать пакеты.
Если у вас просто один компьютер, то убирая все упоминания о локальной сети получим подходящий фаервол.
Особых пояснений не привожу, нужно просто исправить несколько переменных в начале и несколько «таблиц» в середине.
> `#!/bin/bash`
Скачать: [bin-login.name/rc.firewall.txt](http://bin-login.name/rc.firewall.txt)
Здесь можно проверить работу фаервола для TCP в IPv6: [www.subnetonline.com/pages/ipv6-network-tools/online-ipv6-port-scanner.php](http://www.subnetonline.com/pages/ipv6-network-tools/online-ipv6-port-scanner.php) | https://habr.com/ru/post/82885/ | null | ru | null |
# Поиск callback-ов кнопок в рантайме iOS
Основой мобильных приложений является пользовательский интерфейс. По этой причине, при анализе приложения без доступа к исходным кодам, точку входа в определенный блок функциональности кажется логичным искать в этом самом пользовательском интерфейсе прямо во время работы приложения и уже собрав некоторую информацию о логике работы переходить к реверсу.
В данной статье будет рассказано как узнать какой callback будет вызван при нажатие кнопки в интерфейсе iOS приложения с использованием фреймворка [frida](https://frida.re/).
Также я думаю эта статья будет полезна тем разработчикам на iOS кто хочет знать как работает внурянка cllaback-ов графических элементов.
Для нетерпеливых конечный скрипт [тут](https://github.com/chepaika/frida-ios-clicklog).
В чем собственно проблема
-------------------------
Если мы имеем на входе простое одноэкранное приложение то найти нужную кнопку не составит особого труда — достаточно выполнить команду:
```
ObjC.classes.UIWindow.keyWindow().recursiveDescription().toString()
```
И получить список всех имеющихся графических элементов:
```
"; layer = >
| >
| | >
| | | >
| | | | >
| | | | | >"
```
Откуда посредствам ручного анализа достать адрес нужной кнопки (0x10110b540) и посмотреть зарегистрированные обработчики:
```
var button = new ObjC.Object(new NativePointer("0x10110b540"))
button._allTargetActions().toString()
```
В результате получим что-то вроде:
```
"(
\" actionHandler=<\_UIImmutableAction: 0x281891860; title = > events=0x40\",
\" target=0x10110a9d0 action=click1 events=0x40\",
\" target=0x0 action=click2 events=0x40\"
)"
```
Как минимум у нас есть имена двух селекторов — `click1` и `click2`, а для одного из них есть даже объект который его реализует — поле `target` — из которого можно достать имя класса, но об этом позже. В любом случае есть что поискать в IDA для понимания дальнейшей логики работы.
Однако ситуация меняется кардинальным образом когда мы переходим к реальным приложениям где может быть больше одной перекрывающейся сцены и в выводе `keyWindow().recursiveDescription()` появляется больше 30 кнопок. Разбираться со всем этим богатством руками нет никакого желания, а для автоматизации придется немного разобраться в том как происходит обработка нажатий в iOS.
UIEvent
-------
Основой обработки взаимодействия пользователя и приложения составляет `UIEvent`. В целом на хабре есть материалы неплохо раскрывающие данный аспект ([тыц](https://habr.com/ru/post/584100/) и [тыц](https://habr.com/ru/post/464463/)), кроме того рекомендую посмотреть еще [эту](https://medium.com/ios-os-x-development/understanding-cocoa-and-cocoa-touch-responder-chain-12fe558ebe97) стаью. Поэтому эту тему разберм кратко.
Обработка событий генерируемых пользователем происходит следующим образом:
1. При нажатии на экран или другой активности пользователя `UIKit`, на основании данных от ОС генерирует `UIEvent` и кладет его в очередь событий `UIApplication`. События для нашего случая можно разделить на касания экрана и все остальные (пользователь трясет устройство/пользователь нажал аппаратную кнопку/пользователь сгенерил команду от наушников). Далее будем разбирать алгоритм для касания экрана.
2. `UIApplication` достает событие из очереди и если это касание экрана — отправляет его в текущее окно (`UIWindow`)
3. `UIWindow` с помощью метода [hitTest(\_:with:)](https://developer.apple.com/documentation/uikit/uiview/1622469-hittest) определяет самое верхнее `UIView` в пределах которого находиться касание
4. После чего данная вьюшка выбирается первым обработчиком события в цепочке и у нее вызывается один из четырех методов в зависимости от жизненного цикла касания.
Тут надо сделать небольшое лирическое отступление и сказать что все `UIView` равно как и `UIWindow` и `UIApplication` реализуют интерфейс [UIResponder](https://developer.apple.com/documentation/uikit/uiresponder) что позволяет им обрабатывать различные `UIEvent` — ты.
Так вот в случай касания экрана будет вызван один из четырех методов UIResponder-а:
```
func touchesBegan(_ touches: Set, with event: UIEvent?)
func touchesMoved(\_ touches: Set, with event: UIEvent?)
func touchesEnded(\_ touches: Set, with event: UIEvent?)
func touchesCancelled(\_ touches: Set, with event: UIEvent?)
```
Далее у первого `UIResponder` есть три варианта действия:
1) Вызвать реализацию по-умолчанию и передать событие следующему обработчику в цепочке.
2) Провести обработку события и передать его следующему обработчику в цепочке.
3) Провести обработку события и не передавать его дальше.
Для полноты картины осталось разобраться с цепочкой обработчиков:
1) Как было сказано ранее первый обработчик определяется с помощью метода `hitTest(_:with:)` и является самой верхней вьюшкой в пределах которой произошло касание.
2) От первого обработчика событие будет отправлено его родительской `UIView` — [superview](https://developer.apple.com/documentation/uikit/uiview/1622474-superview).
3) Шаг **2** повторяется пока очередь не дойдет до `ViewController`-а.
4) Дальше перебираются `ViewController`-ы пока очередь не дойдет до root-ового контроллера.
5) После него следующим обработчиком становиться `UIWindow`.
6) И последним в данной цепочке является `AppDelegate`.
7) После этого событие просто удаляется.
UIControl
---------
И так `UIEvent` это конечно хорошо и очень интересно однако callback на кнопки обычно вешаются либо через метод [addTarget(\_:action:for:)](https://developer.apple.com/documentation/uikit/uicontrol/1618259-addtarget) либо [addAction(\_:for:)](https://developer.apple.com/documentation/uikit/uicontrol/3600490-addaction) оба из которых относяться к класу `UIControl` и на вход помимо функции принимают событие типа [UIControl.Event](https://developer.apple.com/documentation/uikit/uicontrol/event) а не `UIEvent`.
`addTarget` кроме `UIControl.Event` принимает еще собственно сам `target` — экземпляр класса реализующего callback который может быть еще и `null` и селектор.
На основании полученных данныъ `addTarget` создает объект типа `UIControlTargetAction` заполняет его поля следующим образом
* `UIControlTargetAction._target = target`
* `UIControlTargetAction._action = action`
* `UIControlTargetAction._eventMask = controlEvents`
Затем `addTarget` вызывает метод `UIControl._addControlTargetAction` который проходит по массиву `UIControl._targetActions` и если находит `UIControlTargetAction` с такими же полями `target` и `_action` то добавляет в его поле `_eventMask` значения из маски нового `UIControlTargetAction` (чтобы один callback мог запускаться разными событиями), а если не находит то добавляет новый `UIControlTargetAction` в массив.
`addAction(_:for:)` является нововведением начиная с 14 iOS и имеет схожу логику работу с `addTarget` за исключением того что вместо полей `_target` и `_action` у обьекта `UIControlTargetAction` заполяет поле `_actionHandler` значением типа [UIAction](https://developer.apple.com/documentation/uikit/uiaction).
Так вот от `UIKit` у нас приходят `UIEvent`-ы, а обработчики мы вешаем уже на `UIControl.Event`. Нестыковочка какая-то. Логика конечно подсказывает, что `UIControl` скорее всего тоже является `UIResponder`-ом и таки предпринимает некоторую обработку `UIEvent`-ов. Осталось выяснить какую.
Чтож открываем дизасм `UIControl.touchesEnded`. Почему именно ее? Да потому что обычно обработчик кнопки вешается обычно на событие `UIControl.Event.touchUpInside` — то есть пользователь поднял палец после нажатия, что хорошо вяжется с обработчиком окончания нажатия.
Как видно из дизасма, функция, после обработки поступивших данных о нажатии вызывает `UIControl._sendActionsForEvents(_:UIEvent, withEvent: UIControl.Event)` со следующими возможными `UIControl.Event`-ми:
```
touchDragEnter = 1 << 4 = 16
touchDragExit = 1 << 5 = 32
touchUpInside = 1 << 6 = 64
touchUpOutside = 1 << 7 = 128
```
`_sendActionsForEvents` в свою очередь проходит по массиву сохраненных `UIControlTargetAction` и выбирает тот у которого маска совпадает с переданным `UIControl.Event` -ом, а дальше логика зависит от того установлен ли `_actionHandler` или поле `_action`.
### \_action
В случай если у нас установлен `_action` вызывается [UIControl.sendAction(\_:to:for:)](https://developer.apple.com/documentation/uikit/uicontrol/1618237-sendaction) который достает синглтон UIApplication и вызывает документированный [UIApplication.sendAction(\_:to:from:for:)](https://developer.apple.com/documentation/uikit/uiapplication/1622946-sendaction), куда в качестве `sender` передает себя.
`UIApplication.sendAction` первым делом проверяет не `null` ли таргет и если `null` запускает `UIApplication._targetInChainForAction(_:Selector, sender: Any) -> Any?` которая находит первого (сюрприз) `UIResponder`, только алгоритм обнаружения первого — обратный — первым выбирается самый нижний активный слой.
После этого `UIApplication.sendAction` вызывает уже задокументированный [UIResponder.target(forAction:withSender:)](https://developer.apple.com/documentation/uikit/uiresponder/1621146-target) который проходится вверх по цепочке `UIResponder` — ов и с помощью метода [UIResponder.canPerformAction(\_:withSender:)](https://developer.apple.com/documentation/uikit/uiresponder/1621105-canperformaction) проверяет может ли данный `UIResponder` выполнить переданый селектор и если может — возвращает обьект кторый отозвался. Если ни один объект в цепочке обработчиков не может выполнить данный селектор то возвращается null.
После поиска `target` `UIApplication.sendAction` вне зависимости от результата вызовет либо класический `objc_msgSend` или [perform(\_:with:with:)](https://developer.apple.com/documentation/objectivec/nsobjectprotocol/1418667-perform), благо `objc_msgSend` успешно игнорирует `null` в качестве `id`.
И на этом цепочка поиска и вызова callback-а завершается.
### UIAction aka \_actionHandler
В случай с `UIAction`, установленным в поле `UIControlTargetAction._actionHandler`, `UIControl._sendActionsForEvents` вызывает `UIControl.sendAction(_:UIAction)` который в свою очередь вызывает `UIAction._performActionWithSender`.
`UIAction._performActionWithSender` достает значение лежащее в поле `UIAction.handler` которое является класическим [блоком](https://clang.llvm.org/docs/Block-ABI-Apple.html). Однако в поле `invoke` у нас лежит не указатель на переданное при создании `UIAction` замыкание, а указатель на врапер который потом достает указатель на замыкани по оффсету 0x20 и передает управление ему.
Реализация
----------
После такой достаточно большой теоретической части можно перейти к реализации.
На входе имеем случайное приложение и frida подключенную к нему.
Как мы знаем из теоретической части все callback-и хранятся в массиве `UIControl._targetActions`. Собственно для начала получим все `UIControl` благо для этого есть специальная команда `choose`:
```
uiControls = ObjC.chooseSync(ObjC.classes.UIControl)
```
Теперь для каждого `UIControl` получим массив `_targetActions` и выделим основные кейсы которые следует обработать:
```
var targetActions = uiControl.$ivars._targetActions
// да массив UIControlTargetAction имеет ленивую инициализацию
if (targetActions == null) {
console.log("\tNo callbacks found")
return
}
var count = targetActions.count().valueOf()
for (let i = 0; i !== count; i++) {
var action = targetActions.objectAtIndex_(i)
// Тут мы разбираем три рассмотренных ранее случая
// 1. Когда в качестве обработчика установлен UIAction
if (action.$ivars._actionHandler != null) {
var uiAction = action.$ivars._actionHandler
interceptUIAction(uiAction)
// 2. Когда в качестве обработчика задан селектор и обьект у которого он реализован
} else if (action.$ivars._action != null &&
action.$ivars._action != "0x0" &&
action.$ivars._target != null) {
var actionSelector = action.$ivars._action
var actionTarget = action.$ivars._target
interceptActionWithTarget(actionSelector, actionTarget)
}
// 3. Когда задан только селектор
else if (action.$ivars._action != null &&
action.$ivars._action != "0x0"){
var actionSelector = action.$ivars._action
interceptActionWithoutTarget(actionSelector, uiControl)
}
else {
console.error("Invalid UIControlTargetAction with actionHandler and action seted to null")
continue
}
}
```
В случай если в качестве callback задан `UIAction` я смог достать не так много информации — только дебаг символы если они есть:
```
function interceptUIAction(uiAction) {
var blockAddr = uiAction.$ivars._handler.handle
// достаем адрес замыкания которое будет вызвано ибо invoke() указывает на хелпер
var closurePtr = blockAddr.add(0x20).readPointer()
// и дебаг символы
var closureName = DebugSymbol.fromAddress(closurePtr).name
// по хорошему можно достать еще и sender - UIControl но вопрос на сколько он интересен?
console.log("\tSet hook on: " + closureName)
Interceptor.attach(closurePtr, {
onEnter: function(a) {
this.log = []
this.log.push("Called " + closureName)
},
onLeave: function(r) {
console.log(this.log.join('\n') + '\n')
}})
}
```
Второй случай довольно простой так как у нас есть вся нужная информация — просто вешаем хук.
```
function interceptActionWithTarget(actionSelector, target) {
console.log("\tSet hook on: " + target.$className + "." + actionSelector.readUtf8String() + "()")
var impl = target.methodForSelector_(actionSelector)
Interceptor.attach(impl, {
onEnter: function(a) {
this.log = []
this.log.push("(" + a[0] + ") " + target.$className + "." + actionSelector.readUtf8String() + "()")
},
onLeave: function(r) {
console.log(this.log.join('\n') + '\n')
}})
}
```
А вот в третьем кейсе заболела frida и метод `_targetInChainForAction` почему то отказался находиться в режиме скрипта, при этом в консольном режиме все работало прекрасно. Но никто не мешает нам вызвать метод через `objc_msgSend`:
```
function interceptActionWithoutTarget(actionSelector, uiControl) {
var uiApp = ObjC.classes.UIApplication.sharedApplication()
// создаем функцию из указателя на objc_msgSend
var targetInChainForActionPrototype = new NativeFunction(ObjC.api.objc_msgSend, "pointer", ["pointer","pointer","pointer", "pointer"])
// и вызываем))
var actionTargetPtr = targetInChainForActionPrototype(uiApp, ObjC.selector("_targetInChainForAction:sender:"), actionSelector, uiControl)
var actionTarget = new ObjC.Object(actionTargetPtr)
if (actionTarget != null) {
interceptActionWithTarget(actionSelector, actionTarget)
} else {
console.warn("Can't get target for selector: " + actionSelector.readUtf8String())
}
}
```
Собственно на этом и все! Готовы скрипт лежит [тут](https://github.com/chepaika/frida-ios-clicklog). Надеюсь эта статья поможет кому-то в осознании того как работают callback-и графических элементов в iOS. | https://habr.com/ru/post/713732/ | null | ru | null |
# Ещё один способ устранить ВОШ
#### Задача
ВОШ — эффект, возникающий при стилизации текста подключаемым шрифтом, не установленным на компьютере пользователя. Проявляется, когда подключаемый шрифт *ещё не успел скачаться*, и стилизуемый текст отображается *следующим шрифтом* из значения свойства `font-family` этого элемента. Такое переключение шрифтов также может повлиять на размеры элемента, если они зависят от размеров текста в нём.
Эффект известен также как FOUT — так его [назвал](http://paulirish.com/2009/fighting-the-font-face-fout/) Пол Айриш.
При общих моментах, есть и особенности. Например, в Файрфоксе текст, который нужно будет отрисовать нестандартным шрифтом, [в течение 3 секунд](https://bugzilla.mozilla.org/show_bug.cgi?id=499292) не отображается, в Хроме [тоже есть подобная задержка](https://bugs.webkit.org/show_bug.cgi?id=25207#c28). *Если шрифт успеет скачаться* за это время, текст отобразится сразу нужным шрифтом.
На эту тему здесь была [такая статья](http://habrahabr.ru/post/78551/). В ней последствия ВОШ рекомендовалось нивелировать грамотной игрой со шрифтами. К сожалению, иногда подключаются такие шрифты, которые слишком отличаются по характеристикам от стандартных.
#### Решение
Чтобы устранить ВОШ, я решил указывать шрифт в основном файле стилей при помощи `data:uri`, чтобы шрифт отображался сразу, вместе со страницей.
Остаётся выбрать формат шрифта, понимаемый большинством браузеров посетителей и удобный для загрузки. Широту поддержки форматов подключаемых шрифтов можно узнать [здесь](http://caniuse.com/#feat=fontface).
Шрифты в `eot` наиболее лёгкие, но поддерживаются только ИЕ.
Шрифты в `ttf` и `svg` тяжелы, иногда — конечно, это зависит от шрифта — занимающие в два раза больше места, чем `eot` и `woff`. В моей ситуации я выбрал `woff`, этот формат поддерживается большинством браузеров наших посетителей.
Ещё есть браузеры, которые `woff` не понимают, поэтому указываются альтернативы для них.
ИЕ версии 8 и старше не понимают шрифты в `woff`, им нужен `eot`. В то же время, ИЕ8 не понимает файлы в `data:uri` [тяжелее 32КБ](http://css-tricks.com/data-uris/), а более старшие версии не воспринимают совсем никакие, поэтому в отдельном файле стилей для них можно просто указать ссылки на файлы шрифтов. Чтобы эти браузеры не загружали ненужное, подключение шрифта в `woff` и в других форматах выделено в отдельный файл стилей и отделено условным комментарием.
Также, есть мнение, что под Вин в Хроме `svg`-шрифты выглядят [лучше других](http://www.fontspring.com/demos/svg-vs-woff/), но, мне кажется, это дело вкуса. Шрифт в этом формате [лучше других сжимается](http://www.phpied.com/gzip-your-font-face-files/) при помощи `gzip`, но не поддерживается Файрфоксами и ИЕ.
Таким образом, подгружать шрифты можно при помощи следующего кода:
```
```
```
/* fonts_ie.css */
@font-face {
font-family: 'PT Sans Narrow';
font-style: italic;
font-weight: bold;
src: url('PTS76F_W.eot');
}
```
```
/* fonts.css */
@font-face {
font-family: 'PT Sans Narrow';
font-style: italic;
font-weight: bold;
font-variant: normal;
src: url('data:application/x-font-woff;base64,d09GRgABAAAA...aCw0AAA==') format('woff'),
url('PTN77F_W.svg#PTSans-NarrowBold') format('svg'),
url('PTN77F_W.ttf') format('truetype');
}
```
```
/* main.css */
body {
font-family: 'PT Sans Narrow', 'Arial Narrow', sans-serif;
font-style: italic;
}
```
При использовании этого способа ВОШ остаётся только в неподдерживающих `woff`-шрифты, планомерно теряющих пользователей браузерах, самый распространённый из которых на данный момент — ИЕ8.
[На этой странице](http://ser-gen.github.io/sandbox/tests/fout/test_1.html) шрифт подключен традиционно.
[Здесь](http://ser-gen.github.io/sandbox/tests/fout/test_2.html) шрифт закодирован.
Эффект заметней на медленном соединении.
#### Особенности
Стоит осознать, что при использовании такой техники остаются браузеры, которые **не понимают шрифты** в `woff`, но которым **придётся** их загружать. Тут уже играет роль количество посетителей с такими браузерами и продуктивность их посещений. В моей ситуации оказалось, что лучше устранить ВОШ.
Шрифт **всё равно будет скачиваться**, даже если установлен *локально*. Это сделано, чтобы предотвратить конфликты между начертаниями; будет скачиваться такое, какое нужно.
Страница [не будет отрисовываться](http://www.phpied.com/css-and-the-critical-path/), пока файл стилей со шрифтом не скачается.
Также отмечу, что способ **не подойдёт для шрифтов с лицензией, не позволяющей загружать их при помощи `data:uri`**.
И, конечно, гарантированное решение всех проблем с подгружаемыми шрифтами — **отказаться** от их использования. Серьёзно, иногда они ни к чему.
#### Дополнительная информация
Отличная [отправная точка](http://habrahabr.ru/post/64596/) для изучения темы подключаемых шрифтов
Если нужно подключить шрифт [как обычно](http://habrahabr.ru/post/113136/). [Здесь же](http://habrahabr.ru/post/113136/#comment_3634868) находится комментарий, который я заметил уже после того, как применил этот способ.
Немного [об особенностях подключения](http://paulirish.com/2010/font-face-gotchas/). | https://habr.com/ru/post/180615/ | null | ru | null |
# Использование XenServer и другого free/opensource в ручном тестировании
Хочу рассказать о том, как прижился XenServer в нашем отделе тестирования, а так же немного о другом используемом free/opensource (DRBL + Clonezilla, Tape redirector, MHVTL). Выбор остановился на этих продуктах не по идеологическим, а сугубо практическим причинам — они удобные и масштабируемые. Но есть и ряд проблем, которым я также уделю внимание в этой статье.
Под катом много текста и изображений.
* [Конфигурация оборудования](#hardware)
* [ZFS](#zfs)
* [DRBL and friends](#drbl)
* [XenServer API](#api)
Я работаю в команде тестирования Acronis в отделе поддержки пользователей, воспроизвожу пользовательские проблемы. Начиная с имитации дискового окружения и аппаратной части, заканчивая программным обеспечением и его специфическими настройками. Стояла задача — обеспечить работу тестового стенда с помощью двух рабочих станций. Были перепробованы и ESXi, Hyper-V, Proxmox и другие, но все же остановились на использовании XenServer. И вот что из этого получилось.
#### Аппаратное обеспечение
Изначально имелся один диск, на который и был установлен XenServer 4.2. По началу скорость устраивала. Чуть позже сервером стало пользоваться уже два человека, появилось уже тяжелое окружение (например, Exchange 2003 с базой данных в 300гб, которая постоянно работала под нагрузкой) и сразу стало понятно, что для комфортной работы текущей производительности явно недостаточно. Виртуальные машины грузились долго (а одновременно работает в среднем 20 штук на одном сервере), IO Wait часто достигал нескольких секуд. Надо было что-то делать.
Первое, что пришло в голову — RAID, но быстро это не реализовать, а решение нужно вчера. Как раз тогда в репозитории Debian добавили ZFS и было решено попробовать именно его.
Каждая из двух рабочих станций имеет материнскую плату с 4-мя SATA2 портами, 16ГБ ОЗУ и гигабитные сетевые карты.
Первая машина была выделена под гипервизор и загружается с USB флешки.
На вторую машину была установлена серверная Ubuntu 11.04, все необходимые пакеты для работы ZFS. Установлены 4ре диска по 1ТБ каждый. Был выбран RAID 10. Так как на материнской плате только 4 SATA порта, то ОС так же установлена на USB флешку.
Сам гипервизор соединен с ZFS через гигабитный свитч.
Были проведены эксперименты, прочитаны статьи, в итоге на ZFS была включена поддержка сжатия GZIP, выключена проверка контрольных сум, от дедупликации так же отказались. Это оказалось самым оптимальным решением, все 8 ядер очень редко нагружаются на 100%, и памяти вполне хватает. К сожалению, кэш на SSD протестировать не удалось :)
Сама файловая система экспортируется наружу через NFS, нативно поддерживаемый самим ZFS. А XenServer, да и ESX работают с NFS хранилищами. Это позволило использовать это же хранилище одновременно и для 2-х XenServer и для 3-х ESXi. Из этого ряда выбивается Hyper-V, который с завидным упорством и в Server 2012 отказывается работать с NFS, но это на совести MS.
Сконфигурированный ZFS выглядит так:
```
root@xenzfs:~# zpool status
pool: xen
state: ONLINE
config:
NAME STATE READ WRITE CKSUM
xen ONLINE 0 0 0
mirror-0 ONLINE 0 0 0
sda ONLINE 0 0 0
sdb ONLINE 0 0 0
mirror-1 ONLINE 0 0 0
sdc ONLINE 0 0 0
sdd ONLINE 0 0 0
errors: No known data errors
```
```
root@xenzfs:~# zpool list xen
NAME SIZE ALLOC FREE CAP DEDUP HEALTH ALTROOT
xen 1.81T 1.57T 245G 86% 1.00x ONLINE -
```
Скорость записи на диск примерно соответствует удвоенной скорости отдельного диска.
На данный момент до 40 виртуальных машин одновременно работают без каких либо проблем с производительностью, тогда как раньше 20 машин приводили к провисаниям IOW до 5 секунд. Сейчас, спустя полтора года с запуска ZFS решение можно признать надежным, быстрым и крайне бюджетным. Поднятые NFS и CIFS сервера на хранилище позволяют его использовать и для других целей:
XenServer позволяет создавать ISO хранилища на сетевых дисках CIFS. Продукты перед релизным тестированием собираются в ISO образ (инсталляторы для Windows и Linux разных локализаций), который, в свою очередь, загружен на сетевой диск во внутренней гигабитной сети. В результате, одним движением мышки (субьективно XenCenter гораздо удобнее и быстрее в такой работе, чем vSphere) или скрипта мы вставляем эту ISO в виртульный CDROM (можно и десяткам машин одновременно) и ставим продукт прямо «с диска», что значительно экономит время на копировании больших (2GB+) файлов. Конечно, такое линейное чтение просаживает сеть, особенно если установка идет сразу с 5+ машин, но это все равно очень удобно.
Гигабитная сеть, через которую подключено хранилище, доступна и для виртуальных машин. Таким образом, можно использовать CIFS для любых других тестов. Для удобства на ZFS машине так же был поднят DHCP сервер.
Кроме виртуальных машин, тестировать приходится и на обычных рабочих станциях. Это тестирование и с ленточными накопителями и всевозможные REV, RDX диски и т.д. Нужно постоянно и быстро разворачивать различное окружение на машины. Будь то ESX гипервизор или Windows 2008R2 с Hyper-V или SLES с поднятым iSCSI multipath. Для этой цели используется [DRBL](http://drbl.sourceforge.net/)
DRBL в сочетании с Clonezilla позволяет быстро разворачивать образы чере PXE с гибкими сценариями, а так же служит NAT сервером для уже развернутых машин.
Машины во внутренней сети имеют доступ через NAT во внешнюю сеть, а к ним самим через iptables имеется доступ по RDP.
```
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 3390 -j DNAT --to 192.168.1.50:3389
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 3391 -j DNAT --to 192.168.1.51:3389
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 3392 -j DNAT --to 192.168.1.52:3389
```
Набор различных ленточных накопителей подключен к одной машине, на которой используется бесплатный [Tape Redirector](http://www.starwindsoftware.com/download-starwind-tape-redirector), соответственно любая виртуальная машина может их использовать по iSCSI. Так же имеется отдельная виртуальная машина с поднятым MHVTL, но аппаратные накопители тоже нужны — не все проблемы проявляются на VTL.
Развертывание/клонирование делается в два клика с помощью утилиты, написанной на Perl+GTK. Работает достаточно просто — компонуется команда из блоков и выполняется через SSH. Кому интересно, репозиторий тут. Код сырой, но работает [github.com/Pugnator/GTKdrbl](https://github.com/Pugnator/GTKdrbl)
#### Интерфейс
Субьективно удобный интерфейс представлен только Citrix — XenCenter, но он, к сожалению, только под Windows. Кроме того, по какой-то причине в интерфейс не были выведены важные и полезные возможности, например, возможность поставить виртуальную машину на паузу или, к сожалению, часто нужную опцию перезагрузки XAPI, когда какая-либо виртуальная машина повисает намертво
Есть и другие варианты, например [sourceforge.net/projects/openxenmanager](http://sourceforge.net/projects/openxenmanager/), но они они оказались недостаточно стабильными.
Существует VNC веб прокси [www.xvpsource.org](http://www.xvpsource.org/)
Удобно, но требует Java, включенную в браузере (бывают проблемы), ну и в первую очередь это VNC, работать как с полноценным интерфейсом нельзя.
В результате на GTK3 был написан клиент под Linux, который так же можно использовать и в вебе. GTK Broadway позволяет через HTML5 + WebSockets в браузере получить вот такой инструмент
Данная технология не позволяет использовать его для множества пользователей одновременно, но с помощью неё можно полноценно работать как на Linux, так и через веб, лишь меняя параметры запуска (например, вынести в две иконки).
При использовании HTML5 фронтэнда накладывается множество ограничений на само приложение, и эти ограничения почему-то недокументированы. Примером ограничения является невозможность использования иконок в трее, относительного позиционирования окна и прочее. Последствия — от нестабильной работы до падений.
С документацией все плохо, на данный момент изучение broadway представляет собой чтение исходных кодов GTK3, так как кроме странички описания и новостей 3-х летней давности по broadway ничего нет.
#### API
[API](http://downloadns.citrix.com.edgesuite.net/akdlm/7289/XenServer-6.2.0-SDK.zip) существует для C, C#, Java, Python и Powershell. Для С сборка только под линукс, но методом небольшой доработки исходников (на тот момент в mingw отсутствовала реализация какой-то функции) все успешно собралось и под Windows (MinGW). API работает через HTTP(S). API предоставляет и достаточно низкоуровневый доступ к виртуальным машинам.
#### Диски
Хотелось многого, от быстрого просмотра MBR кликнув мышкой, до извлечения файла с виртуалки или закачивания оного назад на выключенной виртуальной машине.
Такое бывает нужно, к примеру, в случае BSOD — извлечь реестр (и/или отредактировать его и залить обратно, например, выключив какой-либо драйвер), либо отредактировать опции загрузчика (включить дебаг через последовательный порт) и много всего. Для таких целей приходится прибегать к помощи загрузочного диска.
Но можно и иначе, [виртуальную машину возможно экспортировать](http://wiki.xensource.com/wiki/Disk_import/export#HTTP_full_disk_download) через HTTP GET в формате XVA, который представляет из себя TAR архив, внутри которого лежат блоки диска.
```
$ tar -tvf test.xva
---------- 0/0 17391 1970-01-01 01:00 ova.xml
---------- 0/0 1048576 1970-01-01 01:00 Ref:946/00000000
---------- 0/0 40 1970-01-01 01:00 Ref:946/00000000.checksum
---------- 0/0 1048576 1970-01-01 01:00 Ref:946/00000007
---------- 0/0 40 1970-01-01 01:00 Ref:946/00000007.checksum
---------- 0/0 1048576 1970-01-01 01:00 Ref:949/00000000
---------- 0/0 40 1970-01-01 01:00 Ref:949/00000000.checksum
---------- 0/0 1048576 1970-01-01 01:00 Ref:949/00000003
---------- 0/0 40 1970-01-01 01:00 Ref:949/00000003.checksum
```
Если на лету читать этот архив, можно легко получить искомый MBR, и узнав смещения и типы разделов, читать файлы. Но на данный момент реализовано только извлечение MBR. Начиная с версии XenServer 6.2 есть возможность экспортировать RAW диск. В будущих версиях XenServer обещают ввести возможность экспортировать только дельту диска с произвольного смещения, что открывает новые возможности.
#### Сеть
Контролировать работу с сетью виртуальной машины можно разными путями. Обычно это wireshark/tcpdump, установленные в виртуальную машину. Собирается нужный дамп и переносится в другое место для изучения. [Но есть способ лучше](http://support.citrix.com/article/CTX120869) — каждая запущенная виртуальная машина имеет свой dom-id, в соответствии с ним имеется и VIF устройство вида vifDOMID.0, доступное с гипервизора. Подключившись по SSH к гипервизору, можно легко получить дамп для любой произвольной включенной виртуальной машины (разумеется, имеющей добавленные сетевые карты), что делает тестирование чище и удобней (не нужно ставить PCAP драйвера). Далее, [согаласно совету из Q&A](http://ask.wireshark.org/questions/23609/remote-capture-via-ssh-and-pipe) программа делает [пайп](http://wiki.wireshark.org/CaptureSetup/Pipes) и запускает Wireshark. И в режиме реального времени получаем/фильтруем трафик.
#### Guest tools и последовательный порт
API не предоставляет никаких средств, аналогичных guest operation у vix vmWare, например, [копирование файлов](https://www.vmware.com/support/developer/vix-api/vix18_reference/lang/c/functions/VixVM_CopyFileFromHostToGuest.html).
И если с установкой основного софта проблема решается с использованием ISO на гигабитной сети, то с передачей команд/сборкой логов, просмотром данных все не так гладко. Приходится использовать промежуточные сетевые диски, а это не всегда возможно (условия тестирования, изолированная сеть). В любом случае это отнимает время и неудобно.
Самая первая идея, пришедшая в голову — использовать виртуальный последовательный порт. Можно активировать виртуальный com-порт, который средствами XenServer транслируется по TCP. Теперь, если по соответствующему адресу открыто соединение, мы можем отправлять/принимать сообщения на скорости 115200. На виртуальной машине же запущена фоновая программа «последовательный порт-CLI прокси», которая и выполняет транслирование команд из последовательного порта и возвращает результаты.
Тут не обошлось без подводных камней:
1)Передача обрывается при достижении 65535 переданных байт, если клиент (виртуальная машина) не передала за это время хотя бы один байт.
2) Включение порта работает только после рестарта. То есть включать необходимо либо на выключенной виртуальной машине, либо перезагружать её.
3) Если по какой-либо причине соединение оборвется, восстановить его до перезагрузки не имеется возможности.
4) Ну и самое плохое — если TCP сервер не отвечает — виртуальная машина зависнет на старте.
По этим причинам, параллельно искались другие методы, например, через [xenstore](http://wiki.xen.org/wiki/XenStore). Это хранилище, доступное разным доменам. В том числе и виртуальным машинам. Там буфер порядка двух мегабайт, и достаточно быстрая запись. Но чтение медленнее чем 115200, требуются установленные xen tools (что не всегда возможно) и требуется тщательно тестировать код. Например, если записать больше, чем *XENSTORE\_PAYLOAD\_MAX*, судя по комментариям в исходниках драйверов, это грозит фатальными последствиями.
На данный момент думаю об использовании паравиртуального последовательного порта виртуальной машины через ssh тоннель на гипервизор, по аналогии с методом, указанным выше про сетевые карты. Судя по всему, это максимально безопасный и быстрый метод. На данный момент лишь проверено, что это осуществимо.
Точно таким же образом можно производить дебаг ядра Windows/Linux, пробрасывая по TCP/SSH последовательный порт, а локально через пайп уже подключается WinDbg, к примеру. Для таких целей была создана отдельная виртуальная машина с [набором символов под все доступные версии Windows](http://msdn.microsoft.com/en-us/windows/hardware/gg463028).
#### Заключение
Работая с XenServer API и изучая его, на себе испытал многие плюсы и минусы opensource. Широкие возможности упираются в слабую документацию. Если VIX описан очень подробно, то с тем же xenserver api — 3 примера, 4 тестовых файла и комментарии в хэдерах исходников. Код понятный, но как связать отдельные функции — понятно либо разработчикам, либо тем, кто глубоко знает архитектуру Xen. Например, такая задача как узнать размер диска — нигде не описана. А не зная архитектуры — догадаться не слишком просто. Конечно, со временем вникая и углубляясь в строение Xen, многое стало понятней. Но на многие вопросы я так и не получил ответа, а в IRC чатах по выходным никто не отвечает — одинокие посетители пишут, что «сегодня же воскресение» :).
Но прогресс есть, за год пополнились wiki, статьи, примеры с демонстрацией новых возможностей. Очень надеюсь, что в будущем XenServer сможет стать сильным игроком на рынке с хорошим набором third party software | https://habr.com/ru/post/209118/ | null | ru | null |
# Мониторинг докер-хостов, контейнеров и контейнерных служб
Я искал self-hosted мониторинговое решение с открытым кодом, которое может предоставить хранилище метрик, визуализацию и оповещение для физических серверов, виртуальных машин, контейнеров и сервисов, действующих внутри контейнеров. Опробовав Elastic Beats, Graphite и Prometheus, я остановился на Prometheus. В первую очередь меня привлекли поддержка многомерных метрик и несложный в овладении язык запросов. Возможность использования одного и того же языка для графических изображений и уведомления сильно упрощает задачу мониторинга. Prometheus осуществляет тестирование по методу как черного, так и белого ящика, это означает, что вы можете тестировать инфраструктуру, а также контролировать внутреннее состояние своих приложений.
**Почему выбор пал на Prometheus**
* Весь стек можно развернуть с использованием контейнеров.
* Он создан для распределенных систем и инфраструктур.
* Масштабируемый сбор данных, не зависящий от распределенного хранилища.
* Гибкая система обнаружения сервисов (встроенная поддержка для Kubernetes, Consul, EC2, Azure).
* Целевой экспортер для таких сервисов, как HAProxy, MySQL, PostgreSQL, Memcached, Redis и др.
Экосистема Prometheus огромна. Это означает, что можно найти метрические экспортеры для целого ряда систем, начиная от базы данных, MQ, HTTP-серверов до систем, связанных с аппаратными средствами, таких как IoT или IPMI. Тестирование по методу белого ящика также имеет отличное покрытие. Существуют клиентские библиотеки Prometheus для Go, Java, Python, Ruby, .NET, PHP и других языков программирования.
Начало работы с Prometheus и докером
====================================
Если вы хотите попробовать стек Prometheus, обратите внимание на репозиторий dockprom на GitHub. Можно использовать dockprom в качестве начальной точки мониторингового решения. Это позволит с помощью одной команды управлять целым стеком: Prometheus, Grafana, cAdvisor, NodeExporter и AlertManager.
Установка
=========
Скопируйте репозиторий dockprom на докер-хост, перейдите в директорию dockprom и запустите compose up:
```
$ git clone https://github.com/stefanprodan/dockprom
$ cd dockprom
$ docker-compose up -d
```
Контейнеры:
* Prometheus (метрическая база данных) `http://:9090`
* AlertManager (управление оповещениями) `http://:9093`
* Grafana (визуализация метрик) `http://:3000`
* NodeExporter (сборщик хостовых метрик);
* cAdvisor (сборщик метрик контейнеров).
Если Gafana поддерживает аутентификацию, то сервисы Prometheus и AlertManager не имеют такой функции. При наличии базовой аутентификации для Prometheus и AlertManager вы можете удалить отображение портов из файла docker-compose и использовать NGINX как обратный прокси-сервер.
Установка Grafana
=================
Перейдите на `http://:3000` и авторизуйтесь, используя логин *admin* и пароль *changeme*. Вы можете изменить пароль с помощью Grafana UI или изменив файл *user.config*.
Из меню Grafana выберите пункт «Источники данных» (Data Sources) и кликните «Добавить источник данных» (Add Data Source). Чтобы добавить контейнеры Prometheus как источник данных, используйте следующие значения:
* Имя: Prometheus
* Тип: Prometheus
* Url: `http://prometheus:9090`
* Доступ: proxy
Теперь вы можете импортировать шаблоны панели управления из директории Grafana. Из меню Grafana выберите «Панель управления» и нажмите «Импорт».
**Панель управления докера**
На панели управления докера отображены ключевые метрики для мониторинга использования ресурсов вашего сервера.
* Время работоспособности сервера, процент простоя ЦПУ, количество ядер ЦПУ, доступная память, swap и хранилище.
* График средней нагрузки системы, график выполненных и заблокированных IO-процессов, график прерываний.
* График использования ЦПУ в режимах guest, idle, iowait, irq, nice, softirq, steal, system, user.
* График использования памяти по распределению (использовано, свободно, буферы, кэшировано).
* График использования IO (read Bps, read Bps and IO time).
* График использования сети устройствами (входящий Bps, исходящий Bps).
* Использование Swap и графики активности.
**Панель управления контейнеров докера**
Панель управления контейнеров докера отображает ключевые метрики для мониторинга используемых контейнеров.
* Общая нагрузка контейнеров ЦПУ, использование памяти и хранилища.
* График используемых контейнеров, график нагрузки системы, график использования IO.
* График использования контейнера ЦПУ.
* График использования памяти контейнера.
* График использования кэшированной памяти.
* График входящего использования сети контейнеров.
* График исходящего использования сети контейнеров.
На панели не представлены контейнеры, являющиеся частью стека мониторинга.
**Панель управления мониторинговыми сервисами**
Панель управления мониторинговыми сервисами отображает ключевые метрики для мониторинга контейнеров, составляющих мониторинговый стек.
* Время работы контейнера Prometheus, общее использование памяти мониторингового стека, фрагменты и серии памяти локального хранилища Prometheus.
* График использования контейнера ЦПУ.
* График использования памяти контейнера.
* Графики сохраняемых фрагментов Prometheus и срочности сохранения.
* Графики операций фрагментов Prometheus и продолжительности установления контрольных точек.
* Графики процента использованных шаблонов Prometheus, целевых считываний и продолжительности считывания.
* График запросов Prometheus HTTP.
* График уведомлений Prometheus.
Контролировать использование памяти Prometheus можно присоединением фрагментов памяти локального хранилища. Можно изменять максимальное значение фрагментов в docker-compose.yml. Я настроил значение `storage.local.memory-chunks` до 100 000. Если вы мониторите 10 контейнеров, то Prometheus будет использовать около 2 Гб RAM.
Определение уведомлений
=======================
Я установил три файла конфигурации уведомлений:
* Уведомления сервисов мониторинга targets.rules;
* Уведомления хоста докера hosts.rules;
* Уведомления контейнеров докера containers.rules.
Вы можете изменять правила уведомления и перезагружать их с помощью запроса HTTP POST:
```
curl -X POST http://:9090/-/reload
```
Уведомления сервисов мониторинга
--------------------------------
Если один из целевых объектов (node-exporter и cAdvisor) не отвечает более 30 секунд, включите уведомление:
```
ALERT monitor_service_down
IF up == 0
FOR 30s
LABELS { severity = "critical" }
ANNOTATIONS {
summary = "Monitor service non-operational",
description = "{{ $labels.instance }} service is down.",
}
```
Уведомление хоста докера
------------------------
Если ЦПУ хоста докера находится под высокой нагрузкой более 30 секунд, включите уведомление:
```
ALERT high_cpu_load
IF node_load1 > 1.5
FOR 30s
LABELS { severity = "warning" }
ANNOTATIONS {
summary = "Server under high load",
description = "Docker host is under high load, the avg load 1m is at {{ $value}}. Reported by instance {{ $labels.instance }} of job {{ $labels.job }}.",
}
```
Измените пороговое значение нагрузки в соответствии с количеством ядер ЦПУ.
Если память хоста докера заполнена, включите уведомление:
```
ALERT high_memory_load
IF (sum(node_memory_MemTotal) - sum(node_memory_MemFree + node_memory_Buffers + node_memory_Cached) ) / sum(node_memory_MemTotal) * 100 > 85
FOR 30s
LABELS { severity = "warning" }
ANNOTATIONS {
summary = "Server memory is almost full",
description = "Docker host memory usage is {{ humanize $value}}%. Reported by instance {{ $labels.instance }} of job {{ $labels.job }}.",
}
```
Если хранилище хоста докера заполнено, включите уведомление:
```
ALERT hight_storage_load
IF (node_filesystem_size{fstype="aufs"} - node_filesystem_free{fstype="aufs"}) / node_filesystem_size{fstype="aufs"} * 100 > 85
FOR 30s
LABELS { severity = "warning" }
ANNOTATIONS {
summary = "Server storage is almost full",
description = "Docker host storage usage is {{ humanize $value}}%. Reported by instance {{ $labels.instance }} of job {{ $labels.job }}.",
}
```
Уведомления контейнеров докера
------------------------------
Если контейнер не отвечает в течение 30 секунд, включите уведомление
```
ALERT jenkins_down
IF absent(container_memory_usage_bytes{name="jenkins"})
FOR 30s
LABELS { severity = "critical" }
ANNOTATIONS {
summary= "Jenkins down",
description= "Jenkins container is down for more than 30 seconds."
}
```
Если контейнер использует более 10 % ядер ЦПУ более 30 секунд, включите уведомление:
```
ALERT jenkins_high_cpu
IF sum(rate(container_cpu_usage_seconds_total{name="jenkins"}[1m])) / count(node_cpu{mode="system"}) * 100 > 10
FOR 30s
LABELS { severity = "warning" }
ANNOTATIONS {
summary= "Jenkins high CPU usage",
description= "Jenkins CPU usage is {{ humanize $value}}%."
}
```
Если контейнер использует более 1,2 Гб RAM в течение 30 секунд, включите уведомление:
```
ALERT jenkins_high_memory
IF sum(container_memory_usage_bytes{name="jenkins"}) > 1200000000
FOR 30s
LABELS { severity = "warning" }
ANNOTATIONS {
summary = "Jenkins high memory usage",
description = "Jenkins memory consumption is at {{ humanize $value}}.",
}
```
Настройка уведомлений
=====================
Сервис AlertManager отвечает за передачу уведомлений сервера Prometheus. AlertManager может посылать уведомления с помощью электронной почты, Pushover, Slack, HipChat и других систем, использующих интерфейс webhook.
Здесь вы можете просмотреть или выключить уведомления: `http://:9093`.
Получение уведомлений можно настроить в файле alertmanager/config.yml.
Чтобы получать уведомления через Slack, необходимо настроить интеграцию, выбрав «Исходящие сетевые привязки» на странице приложения.
Скопируйте Slack Webhook URL в поле api\_url и определите канал Slack.
```
route:
receiver: 'slack'
receivers:
- name: 'slack'
slack_configs:
- send_resolved: true
text: "{{ .CommonAnnotations.description }}"
username: 'Prometheus'
channel: '#'
api\_url: 'https://hooks.slack.com/services/'
```
Расширение системы мониторинга
==============================
Чтобы покрыть больше одного хоста докера, панель управления Grafana Dockprom можно расширить.. Для контроля большего количества хостов нужно разместить нод-экспортер и контейнер cAdvisor на каждом хосте и указать сервер Prometheus для считывания.
Необходимо активировать стек Prometheus через дата-центр/зону и использовать характеристику интеграции, чтобы объединить все метрики в определенной копии программы Prometheus, которая будет представлять собой общий обзор инфраструктуры. Таким образом, если зона или копия программы Prometheus, задействованная в объединении зон, выйдет из строя, мониторинговая система будет доступна в оставшихся зонах.
Вы также можете сделать Prometheus более отказоустойчивым, запустив два идентичных сервера в каждой зоне. Если несколько серверов будут направлять уведомления в Alertmanager, это не приведет к появлению избыточных данных, так как Alertmanager выполняет дедупликацию. | https://habr.com/ru/post/314212/ | null | ru | null |
# Xscreensaver из часов на Esquire.ru
Мне, жуть, как понравились [вот эти часы](http://esquire.ru/clock), очень захотел на скринсэйвер. Сказано — сделано.
Dev Tools Chromium'а дал понять, что урл видео-файла, проигрываемого плеером выглядит примерно следующим образом:
`http://176.9.156.38/clock/big_<часы>-<минуты, округлённые вниз до делителя 5>.mp4?start=<смещение в секундах относительно округлённого времени>`
1. Bash-скрипт `standardtime` скринсэйвера:
```
#!/bin/bash
hour=$(date +%-H)
ms=$(date +%-M)
sec=$(date +%-S)
rms=$((($ms / 5) * 5))
st=$((($ms - $rms) * 60 + $sec))
secret=$(curl -s "http://esquire.ru/clock" | grep superSecret | grep -o -P "[0-9a-f]+(?=\")")
URL=$(printf "http://176.9.156.38/clock/big_%02d-%02d.mp4?start=%d&pipiska=%s" $hour $rms $st $secret)
exec mplayer -cache 2000 -nosound -nolirc -wid $XSCREENSAVER_WINDOW -nostop-xscreensaver -fs -really-quiet $URL
```
2. Складываем скрипт в `PATH` и делаем его исполняемым.
3. Oткрываем свой `~/.xscreensaver`, находим в нём опцию `programs` и добавляем наш `standardtime` по аналогии:
```
programs: \
maze -root \n\
GL: superquadrics -root \n\
--здесь выброшены другие скринсэйверы--
GL: tronbit -root \n\
standardtime \n\
```
4. Запускаем конфигурацию `xscreensaver` и выбираем в списке наш новоиспечённый скринсэйвер(у меня он назывался `Standardtime`).
5. Лочим экран и наслаждаемся, как мужики переключают семи-позиционный индикатор :)
Зависимости: bash, curl и mplayer.
**UPD:** Убрана зависимость от Python. Спасибо [jov](https://habrahabr.ru/users/jov/).
**UPD:** [sovok\_kpss](https://habrahabr.ru/users/sovok_kpss/) подсказывает, что если заменить в шаблоне урла *big* на *small*, то качество видео будет хуже, но весить будет меньше.
**UPD:** Эскавайр рикроллит хабралюдей. Добавили хэш, который товарищ [gusto](https://habrahabr.ru/users/gusto/) быстренько поимел. Теперь нужен curl.
**UPD:** Воткнули хэшэр на флэше :) Декомпильнём — посмотрим.
**UPD:** А вот и декомилированный код: <http://pastebin.com/LQMCZ21j>
**UPD:** Эсквайр зажал видео за 30 евро. Утром подёргаю этот обфусцированный hmac.
**UPD:** Видео можно найти по [магнет-ссылке](http://magnet:?xt=urn:btih:A5979FA5905E96AFAB035C156AC9B1021738C401&dn=EsquireClock&tr=udp%3a//tracker.openbittorrent.com%3a80/announce). Спасибо [acmer](https://habrahabr.ru/users/acmer/). | https://habr.com/ru/post/143208/ | null | ru | null |
# Использование отладчика Android Studio по максимуму
Это хитрость, о которой я узнал совсем недавно у Senior Android разработчика в моей компании, и теперь я чувствую себя несчастным, сожалея о времени, которое я провел в ожидании сборки Gradle, чтобы проверить свои изменения при написании Android приложений.
Вот типичный сценарий, который каждый Android разработчик мог бы встретить, по крайней мере, один раз в течение своего жизненного цикла разработки. У вас есть список элементов, которые вы хотите показать в **ListView** или **RecyclerView**.
Ниже приведен наш возлюбленный метод `onBindViewHolder`, который связывает вашу модель с вашими view-компонентами **RecyclerView**.
```
@Override
public void onBindViewHolder(ViewHolder holder, final int position) {
final String name = values.get(position);
holder.txtHeader.setText(name);
holder.txtFooter.setText("Footer: " + name);
}
```
Теперь, допустим, вы захотели изменить цвет текста для каждого третьего элемента в списке. Таким образом, код будет выглядеть примерно так:
```
@Override
public void onBindViewHolder(ViewHolder holder, final int position) {
final String name = values.get(position);
holder.txtHeader.setText(name);
if (position % 3 == 0) {
holder.txtHeader.setTextColor(Color.GREEN);
}
holder.txtFooter.setText("Footer: " + name);
}
```
Затем вы нажмёте **Run** и дождётесь завершения сборки и увидите ваши изменения, так?
Теперь вы бы подумали, существует ли другой путь для достижения этой же цели?
Твой выход, Android Studio! Да, нам не нужен внешний плагин или инструмент для достижения вышеупомянутой задачи и более того, нам даже не придется заново собирать проект. Вы не ослышались, мы обойдёмся без Gradle :) Вот как!
### Шаг 1 — Необходимо определить конфигурацию запуска
Такая конфигурация запуска позволит нам запускать наше приложение и присоединять к нему отладчик из Android Studio, а также вы сможете присоединить его к уже запущенному процессу.
Нажмите **Run → Edit Configurations**.
В верхнем левом углу диалогового окна щелкните значок «+» и выберите **Android App**.
Теперь дайте ему имя, мне нравится называть его **Run-Only**, но вы можете называть его как угодно.
Выберите модуль, который содержит код вашего приложения, в приведенном ниже скриншоте он называется *app*.
**Важный шаг:**
В разделе Installation Options выберите **Nothing**;
В Launch Options выберите **Default Activity**;
В разделе Before Launch удалите **Gradle-aware Make**.
Таким образом, конфигурация должна выглядеть следующим образом:
Теперь вы можете применить и сохранить эту конфигурацию. Сейчас она должна быть выбрана автоматически. Если нет, то просто выберите её из списка.
Теперь поставьте *breakpoint* поближе к строке, которую вы хотите проверить. В нашем случае мы разместим ее там, где мы устанавливаем текст.
Щелкните правой кнопкой мыши на *breakpoint* и снимите флажок **Suspend** (рус. *приостановить*).
Как только вы снимете флажок, диалог расширится и покажет больше опций.
Нам интересен раздел **Evaluate and log**. Мы напишем там выражение, чтобы проверить изменения в нашем элементе RecyclerView. Нажмите на маленький значок голубого цвета справа от окна ввода *Evaluate and log*, чтобы развернуть его до более крупного редактора, и добавьте выражение для тестирования, и нажмите **Ok**, а затем **Done**.
Теперь нажмите на иконку **Debug** с выбранной конфигурацией *Run-Only* и посмотрите на эту магию.
Приложение должно запуститься с вашей Activity по умолчанию, и вы должны увидеть внесенные там изменения. Также, если вы уделяете пристальное внимание IDE, в самом низу вы увидите только одну запускаемую задачу: *Launching Activity*.
Хотелось бы услышать ваши впечатления, когда вы опробуете эту хитрость! | https://habr.com/ru/post/419613/ | null | ru | null |
# Как переехать с ESXi на KVM/LXD и не сойти с ума
В компании «Макснет Системы» в качестве гипервизора долгое время использовалась бесплатная версия VMware — ESXi, начиная с версии 5.0. Платная версия vSphere отпугивала моделью лицензирования, а у бесплатной был ряд недостатков, которые отсутствовали в платной, но с ними можно было смириться. Но когда в новых версиях ESXi новый веб-интерфейс отказался работать со старым, а мониторинг RAID-массивов перестал подавать признаки жизни, компания решила искать более универсальное и открытое решение. В компании уже был неплохой опыт и приятное впечатление от LXC — Linux Containers. Поэтому стало очевидно, что гипервизор мечты будет гибридным и сочетать для разных нагрузок KVM и LXD — эволюционное продолжение LXC. В поисках информации относительно KVM, компания сталкивалась с заблуждениями, граблями и вредными практиками, но тесты и время расставили все по местам.
О том, как справиться с переездом с ESXi на KVM и не проколоть колеса на граблях, расскажет **Лев Николаев** ([maniaque](https://habr.com/ru/users/maniaque/)) — администратор и разработчик высоконагруженных систем, тренер по информационным технологиям. Поговорим о Сети, хранилищах, контейнерах, KVM, LXD, LXC, provisioning и удобных виртуалках.
Пролог
------
Сразу обозначим ключевые мысли, а дальше разберем их подробнее.
**Сеть.** Пока скорости ваших интерфейсов не превышают 1 Гбит/с, вам хватит bridge. Как только захотите выжать больше — он будет вас ограничивать.
**Хранилище.** Создайте общее сетевое хранилище. Даже если вы не готовы внутри сети использовать 10 Гбит/с, то даже 1 Гбит/с даст вам 125 МБ/с хранилища. Для целого ряда нагрузок этого будет достаточно с запасом, а миграция виртуальных машин будет элементарным делом.
**Контейнер или KVM?** Плюсы, минусы, подводные камни. Какие виды нагрузки лучше положить в контейнер, а какие лучше оставить в KVM?
**LXD или LXC**. LXD — это LXC? Или другая версия? Или надстройка? Что это вообще? Развеем мифы и поймем, в чем отличия между LXD и LXC.
**Удобный provisioning**. Что удобнее: брать одинаковый образ или инсталлировать систему с нуля каждый раз? Как это делать быстро и аккуратно каждый раз?
**Удобная виртуальная машина.** Здесь будут страшные рассказы о загрузчиках, разделах, LVM.
**Разное**. Много мелких вопросов: как быстро перетащить виртуальную машину c ESXi на KVM, как хорошо мигрировать, как правильно виртуализировать диски?
Причина переезда
----------------
Откуда у нас появилась безумная идея переезда с ESXi на KVM/LXD? ESXi популярно среди малого и среднего бизнеса. Это хороший и дешевый гипервизор. Но есть нюансы.
Мы начинали с версии 5.0 — удобно, все работает! Следующая версия 5.5 — тоже.
С версии 6.0 — уже сложнее. На ESXi Web-интерфейс не сразу стал бесплатным, только с версии 6.5, до этого требовалась утилита под Windows. Мы с этим смирились. Кто работает на OS X покупает Parallels и ставит эту утилиту. Это всем известная боль.
Периодически слетал мониторинг. Приходилось в консоли сервера перезапускать службы менеджмента — тогда снова появлялся CIM Heartbeat. Мы терпели, так как он не всегда отваливался.
Версия ESXi 6.5 — треш, угар и бесчинства. Ужасный гипервизор. И вот почему.
* **Angular вываливается с исключением еще на входе в Web-интерфейс.** Как только вы вводите логин и пароль — сразу исключение!
* **Не работает возможность удаленно мониторить статус RAID-массива** так, как удобно нам. Раньше было удобно, а в версии 6.5 — все плохо.
* **Слабая поддержка современных сетевых карт от Intel**. Сетевые карты от Intel и ESXi порождают боль. На форуме поддержки ESXi есть ветка агонии по этому поводу. VMware и Intel не дружат и в ближайшее время отношения не улучшатся. Печально то, что проблемы испытывают даже клиенты платных решений.
* **Нет миграции в рамках ESXi**. Если только не считать миграцией процедуру с паузой, копированием и запуском. Ставим машину на паузу, быстро ее копируем и запускаем в другом месте. Но назвать это миграцией нельзя — все-таки есть простой.
Посмотрев на это все, у нас и появилась безумная идея переезда с ESXi 6.5.
Список пожеланий
----------------
Для начала мы написали список пожеланий идеального будущего, в которое мы уходим.
**Управление из-под SSH**, а Web и прочее опционально. Web-интерфейс — это здорово, но в командировке с iPhone зайти в Web-интерфейс ESXi и что-то там сделать неудобно и тяжело. Поэтому, единственный способ управлять всем — это SSH, другого не будет.
**Виртуализация Windows.** Иногда клиенты просят странные вещи, а наша миссия — им помогать.
**Всегда свежие драйвера и возможность настраивать сетевую карту**. Адекватное желание, но нереализуемое под чистым ESXi.
**Живая миграция, а не кластеризация**. Мы хотим возможность перетаскивать машины с одного гипервизора на другой, не ощущая никаких задержек, простоев и неудобств.
Список желаний готов, дальше начался тяжелый поиск.
Муки выбора
-----------
Рынок крутится вокруг KVM или LXC под разными соусами. Иногда кажется, что Kubernetes где-то сверху, где все хорошо, солнце и рай, а на уровне ниже сидят морлоки — KVM, Xen или что-то подобное…
Например, Proxmox VE — это Debian, на который натянули ядро от Ubuntu. Это выглядит странно, но приносить ли это в продакшн?
Наши соседи этажом ниже — Alt Linux. Они придумали красивое решение: собрали Proxmox VE в виде пакета. Они просто ставят пакет одной командой. Это удобно, но мы не катаем Alt Linux в продакшн, поэтому нам не подошло.
### Берем KVM
В итоге мы выбрали KVM. Не взяли, Xen, например, из-за сообщества — оно у KVM сильно больше. Казалось, что мы всегда найдем ответ на свой вопрос. Позже мы выяснили, что размер сообщества не влияет на его качество.
Изначально мы рассчитывали, что возьмем Bare Metal машину, добавим Ubuntu, с которой работаем, а сверху будем катать KVM/LXD. Мы рассчитывали на возможность запускать контейнеры. Ubuntu хорошо знакомая система и никаких сюрпризов в плане решения проблем загрузки/восстановления для нас нет. Мы знаем куда пинать, если гипервизор не заводится. Нам все понятно и удобно.
Ускоренный курс по KVM
----------------------
Если вы из мира ESXi, то вас ждет много интересного. Выучите три слова: QEMU, KVM и libvirt.
**QEMU** транслирует желания виртуализируемых ОС в вызовы обычного процесса. Отлично работает практически везде, но медленно. Сам по себе QEMU — это отдельный продукт, который виртуализирует кучу других устройств.
Дальше на сцену выходит связка **QEMU-KVM**. Это модуль ядра Linux для QEMU. Все инструкции виртуализировать дорого, поэтому у нас есть модуль ядра KVM, который **транслирует только некоторые инструкции**. Как результат — это ощутимо быстрее, потому что обрабатывается всего несколько процентов инструкций от общего набора. Это и есть все издержки на виртуализацию.
Если у вас просто QEMU, запуск виртуальной машины без обвязки выглядит так:
```
$ qemu <миллион параметров>
```
В параметрах описываете сеть, блочные устройства. Все замечательно, но неудобно. Поэтому есть libvirt.
**Задача libvirt — быть единым инструментом для всех гипервизоров**. Он может работать с чем угодно: с KVM, с LXD. Кажется, что остается только учить синтаксис libvirt, но на деле он работает хуже, чем в теории.
Эти три слова — все, что нужно, чтобы поднять первую виртуалку в KVM. Но опять-таки есть нюансы…
У libvirt есть конфиг, где хранятся виртуалки и прочие настройки. Он хранит конфигурацию в xml-файлах — стильно, модно и прямо из 90-х. При желании их можно редактировать руками, но зачем, если есть удобные команды. Также удобно то, что изменения xml-файлов чудесно версионируются. Мы используем **etckeeper** — версинонируем директорию etc. Использовать etckeeper уже можно и давно пора.
Ускоренный курс по LXC
----------------------
По поводу LXC и LXD существует множество заблуждений.
> LXC — это возможность современного ядра использовать namespaces — делать вид, что оно совсем не то ядро, что было изначально.
Этих namespaces можно создавать сколько угодно под каждый контейнер. Формально ядро одно, но ведет себя как много одинаковых ядер. LXC позволяет запускать контейнеры, но предоставляет только базовые инструменты.
Компания Canonical, которая стоит за Ubuntu и агрессивно двигает контейнеры вперед, выпустила **LXD — аналог libvirt**. Это обвязка, которая позволяет удобнее запускать контейнеры, но внутри это все равно LXС.
> LXD — это гипервизор контейнеров, который базируется на LXС.
В LXD царствует энтерпрайз. LXD хранит конфиг в своей базе — в директории `/var/lib/lxd`. Там LXD ведет свой конфиг в конфиг в SQlite. Копировать его не имеет смысла, но можно записывать те команды, которые вы использовали для создания конфигурации контейнера.
Выгрузки как таковой нет, но большая часть изменений автоматизируется командами. Это аналог Docker-файла, только с ручным управлением.
Продакшн
--------
С чем мы столкнулись, когда на этом всем поплыли в эксплуатацию.
### Сеть
Сколько же адского треша и угара в интернете о сети в KVM! 90% материалов говорят использовать bridge.
> Перестаньте использовать bridge!
Что с ним не так? В последнее время у меня ощущение, что с контейнерами творится безумие: поставим Docker поверх Docker, чтобы можно было запускать Docker в Docker смотря Docker. Большинство не понимает, что делает bridge.
Он помещает ваш сетевой контроллер в **promiscuous mode** и принимает весь трафик, потому что не знает, какой его, а какой нет. В результате весь трафик bridge идет через замечательный, быстрый сетевой Linux-стек, а там много копирования. В итоге все медленно и плохо. Поэтому не используйте bridge в продакшн.
### SR-IOV
**SR-IOV — это возможность виртуализироваться в пределах сетевой карты**. Сама сетевая карта умеет выделять часть себя для виртуальных машин, что требует определенной поддержки железом. Именно это и будет мешать мигрировать. Миграция виртуальной машины туда, где отсутствует SR-IOV, болезненна.
SR-IOV надо использовать там, где оно поддерживается всеми гипервизорами, в рамках миграции. Если же нет, то для вас есть macvtap.
### macvtap
Это для тех, у кого сетевая карта не поддерживает SR-IOV. Это light-версия bridge: на одну сетевую карту навешиваются разные MAC-адреса, и используется **unicast filtering**: сетевая карта принимает не все подряд, а строго по списку MAC-адресов.
Больше кровавых подробностей можно прочитать в замечательном докладе Toshiaki Makita [«Virtual switching technologies and Linux bridge»](https://events.static.linuxfound.org/sites/events/files/slides/LinuxConJapan2014_makita_0.pdf). Он полон боли и страдания.
> 90% материалов о том, как строить сеть в KVM, бесполезны.
Если кто-то говорит, что bridge это классно — не разговаривайте больше с этим человеком.
С macvtap **CPU экономит около 30%** за счет меньшего числа копирований. Но с promiscuous mode есть свои нюансы. Нельзя с самого гипервизора — с хоста, — соединиться с сетевым интерфейсом гостевой машины. В докладе Toshiaki подробно описано об этом. Но если кратко — не получится.
С самого гипервизора редко ходят по SSH. Там удобнее стартовать консоль, например, Win-консоль. «Смотреть» трафик на интерфейсе возможно — нельзя по TCP соединиться, но трафик на гипервизоре видно.
> Если ваши скорости выше 1 Гигабита — выбирайте macvtap.
При скоростях интерфейса до или около 1 Гигабита в секунду можно использовать и bridge. Но если у вас сетевая карта на 10 Gb и вы хотите как-то ее утилизировать, то остается только macvtap. Никаких других вариантов нет. Кроме SR-IOV.
### systemd-networkd
**Это отличный способ хранить сетевую конфигурацию на самом гипервизоре**. В нашем случае это Ubuntu, но и для других систем systemd работает.
Раньше у нас был файл `/etc/network/interfaces`, в котором мы все держали. Один файл неудобно редактировать каждый раз — systemd-networkd позволяет разбить конфигурацию на россыпь маленьких файлов. Это удобно, потому что работает с любой системой версионирования: отправили в Git и видите, когда и какое изменение произошло.
Есть недостаток, который обнаружили наши сетевики. Когда нужно добавить новый VLAN в гипервизоре, я иду и конфигурирую. Потом говорю: «systemctl restart systemd-networkd». В этот момент у меня все хорошо, но если подняты BGP-сессии с этой машины — они рвутся. Наши сетевики это не одобряют.
Для гипервизора ничего страшного не происходит. Systemd-networkd непригодно для пограничных бордеров, серверов с поднятым BGP, а для гипервизоров — отлично.
Systemd-networkd далек от финала и не будет закончен никогда. Но это удобнее, чем редактировать один огромный файл. Альтернатива systemd-networkd в Ubuntu 18.04 — Netplan. Это «классный» способ конфигурировать сеть и наступать на грабли.
### Устройство сети
После установки KVM и LXD на гипервизор, первое, что вы увидите, — два bridge. Один себе сделал KVM, а второй — LXD.
> LXD и KVM пытаются развернуть свою сеть.
Если вам все-таки нужен bridge — для тестовых машин или поиграться, убейте bridge, который включается по умолчанию и создайте свой — такой, какой хотите. KVM или LXD это делают ужасно — подсовывают dnsmasq, и начинается ужас.
### Хранилище
> Не важно, какие реализации вам нравятся — используйте общее хранилище.
Например, по iSCSI для виртуальных машин. Вы не избавитесь от «точки отказа», но сможете **консолидировать хранение в одной точке**. Это открывает новые интересные возможности.
Для этого надо внутри дата-центра иметь интерфейсы хотя бы 10 Гбит/с. Но даже если у вас только 1 Гбит/с — не огорчайтесь. Это примерно 125 Мбайт/с — вполне хорошо, для гипервизоров, которые не требуют высокой дисковой нагрузки.
KVM умеет мигрировать и перетаскивать хранилища. Но, например, в режиме рабочей нагрузки перенос виртуальной машины на пару Терабайт — это боль. Для миграции с общим хранилищем хватает передачи только оперативной памяти, что элементарно. Это **сокращает время миграции**.
### В итоге LXD или KVM?
Первоначально мы полагали, что для всех виртуалок, где ядро совпадает с хостовой системой, мы возьмем LXD. А там, где нам нужно брать другое ядро — возьмем KVM.
В реальности планы не взлетели. Чтобы понять почему, посмотрим внимательнее на LXD.
### LXD
Главный плюс — экономия памяти на ядре. Ядро одно и когда запускаем новые контейнеры ядро все то же. На этом плюсы кончились и начались минусы.
**Блочное устройство c rootfs надо монтировать.** Это тяжелее, чем кажется.
**Миграции толком нет**. Она есть, и базируется на чудесном сумрачном инструменте criu, который пилят наши соотечественники. Я горжусь ими, но в простых случаях criu не работает.
**zabbix-agent странно ведет себя в контейнере**. Если его запустить внутри контейнера, то ряд данных вы увидите с хостовой системы, а не из контейнера. Пока с этим ничего сделать нельзя.
**При взгляде на список процессов на гипервизоре, невозможно быстро понять, из какого контейнера растет конкретный процесс**. Требуется время, чтобы выяснить, какой там namespace, что и куда. Если нагрузка где-то подскочила больше, чем обычно, то быстро это не понять. Это главная проблема — ограничение в возможностях реагирования. Для каждого случая проводится мини-расследование.
> Единственный плюс LXD — экономия памяти на ядре и сокращение overhead.
Но Kernel Shared Memory в KVM и так экономит память.
Пока не вижу причин знакомить серьезный продакшн и LXD. Несмотря на все усилия Canonical в этой области, LXD в продакшн приносит больше проблем, чем решений. В ближайшее время ситуация не изменится.
Но, нельзя сказать, что LXD это зло. Он хорош, но в ограниченных случаях, о которых расскажу чуть позже.
### Criu
Criu — это сумрачная утилита.
Создайте пустой контейнер, он приедет с DHCP-клиентом и скажите ему: «Suspend!» Получите ошибку, потому что там DHCP-клиент: «Ужас-ужас! Он сокет открывает с признаком «raw» — какой кошмар!» Хуже некуда.
> Впечатления от контейнеров: миграции нет, Criu работает через раз.
Мне «нравится» рекомендация от команды LXD, что делать с Criu, чтобы не было проблем:
— *Возьмите из репозитория версию посвежее!*
А можно ее как-то из пакета поставить, чтобы не бегать в репозиторий?
### Выводы
**LXD чудесен, если хочется создать CI/CD инфраструктуру.** Мы берем LVM — Logical Volume Manager, делаем с него снапшот, и на нем стартуем контейнер. Все отлично работает! За секунду создается новый чистый контейнер, который настроен для тестирования и прокатки chef — мы это активно используем.
**LXD слаб для серьезного продакшн**. Мы не можем понять, что делать с LXD в продакшн, если он плохо работает.
**Выбираем KVM и только KVM!**
### Миграция
Скажу об этом кратко. Для нас миграция оказалась чудесным новым миром, который нам нравится. Там все просто — есть команда для миграции и две важные опции:
```
virsh migrate qemu+ssh:///system --undefinesource -persistent
```
Если наберете в Google «KVM migration» и откроете первый же материал, то увидите команду для миграции, но без двух последних ключей. Вы не увидите упоминания, что они важны: «Просто выполните эту команду!» Выполните команду — а оно действительно мигрирует, но только как?
Важные опции миграции.
**undefinesource — удалить виртуальную машину из гипервизора, с которого мигрируем.** Если после такой миграции ребутнетесь, то гипервизор, с которого вы ушли, заново запустит эту машину. Вы удивитесь, но это нормально.
**Без второго параметра — persistent — гипервизор, куда вы переехали, вообще не считает, что это постоянная миграция.** После ребута гипервизор ничего не вспомнит.
```
- virsh dominfo | grep persistent
```
Без этого параметра виртуальная машина — круги на воде. Если первый параметр указан без второго, то догадайтесь, что будет.
С KVM таких моментов много.
* Сеть: вам все время рассказывают про bridge — это кошмар! Читаешь и думаешь — как так?!
* Миграция: про нее тоже ничего внятного не скажут, пока сами головой не побьетесь об эту стенку.
С чего начать?
--------------
Поздно начинать — я про другое.
### Provisioning: как это разворачивать
> Если вас устраивают стандартные опции установки, то механизм preseed прекрасен.
Под ESXi мы использовали virt-install. Это штатный способ разворачивать виртуальную машину. Он удобен тем, что вы создаете preseed-файл, в котором описываете образ вашего Debian/Ubuntu. Запускаете новую машину, скормив ей ISO дистрибутива и preseed-файл. Дальше машина сама раскатывается. Вы подсоединяетесь к ней по SSH, цепляете ее в chef, прокатываете кукбуки — все, понеслись в прод!
Но если вам хватает virt-install, у меня плохие новости. Это значит, что вы еще не дошли до стадии, когда хочется что-то сделать иначе. Мы дошли и поняли, что virt-install недостаточно. Мы пришли к некоторому «золотому образу», который мы клонируем и потом запускаем виртуалки.
### А как правильно устроить виртуальную машину?
Почему мы пришли к этому образу, и почему вообще provisioning важен? Потому что до сих пор в community слабое понимание, что между виртуальной машиной и обычной машиной большие отличия.
**Виртуальной машине не нужен сложный процесс загрузки и умный загрузчик**. Гораздо проще прицепить диски виртуальной машины к машине, у которой есть полный набор инструментов, чем в recovery mode пытаться куда-то вылезти.
**Виртуальной машине нужна простота устройства**. Зачем нужны разделы на виртуальном диске? Зачем люди берут виртуальный диск, и ставят туда разделы, а не LVM?
**Виртуальной машине нужна максимальная расширяемость**. Обычно виртуалки растут. Это «классный» процесс — увеличение раздела в MBR. Вы его удаляете, в этот момент вытирая пот со лба и думаете: «Только не записать бы сейчас, только бы не записать!» — и создаете заново с новыми параметрами.
### LVM @ lilo
В итоге мы пришли к LVM @ lilo. Это загрузчик, который позволяет настраиваться из одного файла. Если для настройки конфига GRUB вы редактируете специальный файл, который управляет шаблонизатором и строит монструозный boot.cfg, то с Lilo — один файл, и больше ничего.
LVM без разделов позволяет сделать систему идеальной легко и просто. Проблема в том, что GRUB без MBR или GPT жить не может и идет на мороз. Мы ему говорим: «GRUB установись сюда», а он не может, потому что разделов нет.
LVM позволяет быстро расширяться и делать резервные копии. Стандартный диалог:
*— Ребята, а как вы делаете виртуалке бэкап?*
*— … мы берем block device и копируем.*
*— Развертывать обратно пробовали?*
*— Ну нет, у нас же все работает!*
Можно block device в виртуальной машине слизать в любой момент, но если там файловая система, то любая запись в нее требует трех телодвижений — эта процедура не атомарна.
Если вы изнутри делаете снапшот виртуальной машины, то она умеет говорить с файловой системой, чтобы та пришла в нужное консистентное состояние. Но это не для всего подходит.
Как строить контейнер?
----------------------
Для запуска и создания контейнера есть штатные средства из шаблонов. LXD предлагает шаблон Ubuntu 16.04 или 18.04. Но если вы продвинутый боец и хотите не штатный шаблон, а свой кастомный rootfs, который настроите под себя, то возникает вопрос: а как в LXD создавать контейнер с нуля?
### Контейнер с нуля
**Подготавливаем rootfs**. В этом поможет debootstrap: объясняем, какие пакеты нужны, какие нет — и ставим.
**Объяснить LXD, что мы хотим создать контейнер из конкретного rootfs**. Но сначала создаем пустой контейнер короткой командой:
```
curl --unix-socket /var/lib/lxd/unix.socket -X POST -d '{"name": "my-container", "source": {"type": "none"}}' lxd/1.0/containers
```
Это даже можно автоматизировать.
Вдумчивый читатель скажет — а где rootfs my-container? Где указано, в каком месте он лежит? Но я же не сказал, что это все!
**Монтируем rootfs контейнера** туда**,** где он будет жить. Потом указываем, что у контейнера rootfs будет жить вот там:
```
lxc config set my-container raw.lxc "lxc.rootfs=/containers/my-container/rootfs"
```
Опять же это автоматизируется.
### Жизнь контейнеров
**У контейнера нет своего ядра**, поэтому загрузка у него проще**:** systemd, init и полетели!
Если вы не используете штатные средства для работы с LVM, то в большинстве случаев для запуска контейнера понадобится монтировать rootfs контейнера в гипервизоре.
Я иногда нахожу статьи, в которых советуют «autofs». Не делайте так. У systemd есть automount-юниты, которые работают, а autofs — нет. Поэтому systemd automount-юниты можно и нужно использовать, а autofs — не стоит.
Выводы
------
**Нам по вкусу KVM с миграцией**. С LXD пока не по пути, хотя для тестов и построения инфраструктуры мы ее используем — там, где нет продакшн-нагрузки.
**Нам нравится производительность KVM**. Привычнее смотреть в top, видеть там процесс, который имеет отношение к этой виртуальной машине, и понимать, кто и чем у нас занимается. Это лучше, чем при помощи набора странных утилит с контейнерами выяснять, что там за подводные стуки.
**Мы в восторге от миграции.** Во многом это благодаря общему хранилищу. Если бы мы мигрировали, перетаскивая диски, то были бы не так счастливы.
> Если вы так же, как и Лев, готовы рассказать о преодолении сложностей эксплуатации, интеграции или поддержки, то сейчас самое время [подать доклад](https://conf.ontico.ru/lectures/propose/?conference=dc2019-moscow) на осеннюю конференцию [DevOpsConf](https://devopsconf.io/moscow/2019). А мы в программном комитете поможем подготовить такое же воодушевляющие и полезное выступление, как это.
>
>
>
> Мы не дожидаемся дедлайна Call for Papers и уже приняли несколько докладов в [программу](https://devopsconf.io/moscow/2019/abstracts) конференции. Подпишитесь на [рассылку](http://eepurl.com/bN_0E1) и [telegram-канал](https://t.me/DevOpsConfChannel) и будете в курсе новостей о подготовке к DevOpsConf 2019 и не пропустите новые статьи и видео. | https://habr.com/ru/post/458922/ | null | ru | null |
# Внедрение зависимостей в .Net Марка Симана 2 — Внедрение конструктора, время жизни
[Зависимости между слоями приложения](https://habrahabr.ru/post/343830/) | Внедрение конструктора, время жизни | [Сквозные аспекты приложения, перехват, декоратор](https://habrahabr.ru/post/344986/)
Продолжаем борьбу за слабую связанность. В предыдущей заметке мы рассмотрели зависимости между слоями приложения, прейдем к меньшим формам.
Агрегация, внедрение конструктора
---------------------------------
Объекты/классы системы, как и слои, взаимодействуют друг с другом. Между классами тоже есть зависимости.
Например, в листинге 1 MyService использует MyDataContext (EF) – имеет зависимость MyDataContext.
```
class MyService
{
public void DoSomething()
{
using(var dbCtx = new MyDataContext())
{
// используем dbCtx
}
}
}
Листинг 1. Сильная зависимость MyService от MyDataContext
```
У кода выше есть недостатки:
— используется антипаттерн «Диктатор»: MyService сам создает и контролирует время жизни свой зависимости MyDataContext.
— нарушен принцип инверсии зависимости (Dependency Inversion Principle, DIP) (куда же в «наукообразной» статье без SOLID): MyService зависит от конкретной реализации MyDataContext, было бы лучше использовать интерфейс/абстрактный класс.
> Принцип инверсии зависимости (Dependency Inversion Principle, DIP)
>
>
>
> Фактически синоним для требования «Программировать в соответствии с интерфейсом, а не с конкретной реализацией».
>
> (цитата из книги)
Улучшим код с помощью агрегации — листинг 2:
```
class MyService
{
private readonly IRepository Repository;
public MyService(IRepository repository){
if(repository == null)
throw new ArgumentNullException(nameof(repository));
Repository = repository;
}
public void DoSomething()
{
// используем Repository
}
}
Листинг 2. Агрегация. MyService не создает и не управляет временем жизни свой зависимости Repository
```
Отступление:
[Хорошая статья про агрегацию и композицию](http://sergeyteplyakov.blogspot.ru/2012/12/vs-vs.html) написана Сергеем Тепляковым. Кроме прочего статья научит вас рисовать умные схемы. В качестве спойлера: какая схема описывает агрегацию?
*Рис 1. Схемы композиции и агрегации*
Вернемся к листингу 2. Это и есть внедрение зависимости, при том лучший вариант — «Внедрение конструктора». Связанность уменьшилась, но появился вопрос: как же вызвать Dispose репозитория? Помните в листинге 1 использовался Using?
> Класс, передавший управление своими зависимостями, теряет более чем просто возможность выбирать конкретные реализации абстракций. Он также теряет возможность управления как моментом создания экземпляра, так и моментом, когда этот экземпляр становится недоступным.
>
> (цитата из книги)
Интересное замечание: если класс имеет более 4-х зависимостей (более 4-х параметров конструктора) – это повод задуматься над рефакторингом. Похоже, что объект выполняет слишком много функций, нарушается принцип единичной ответственности (Single Responsibility Principle, SRP – опять SOLID).
Время жизни зависимостей
------------------------
Отвечая на вопрос “как же вызвать Dispose репозитория?” Марк предлагает пойти на компромисс. MyService не должен знать об особенностях реализации IRepository, в том числе о необходимости освобождения ресурсов. Т.е. вот такое определение IRepository нежелательно:
```
interface IRepository : IDisposable
{
void DeleteProduct(int id);
}
```
Кроме того, что такой интерфейс открывает потребителю (MyService) часть знания о конкретной реализации, он еще накладывает ограничение на возможные реализации – они должны реализовать IDisposable (может он им не нужен).
А в имплементации IRepository это знание, о реализации, допускается – листинг 3.
```
class SqlRepository : IRepository
{
IDataContextFactory DbContextFactory;
public SqlRepository(IDataContextFactory dbContextFactory)
{
if(dbContextFactory == null)
throw new ArgumentNullException(nameof(dbContextFactory));
DbContextFactory = dbContextFactory;
}
public void DeleteProduct(int id);
{
using(var dbCtx = DbContextFactory.Create())
{
// использование dbCtx
}
}
}
Листинг 3. Реализация IRepository инкапсулирует работу с базой данных
```
Дополнение (не самое главное): SqlRepository управляет временем жизни DataConext, но создание вынесено в фабрику.
В этом и заключается компромисс: да, SqlRepository управляет временем жизни DataContext, но это не влияет на остальной код.
Выше описано хорошее решение, но применить его не всегда возможно. Например, нужна транзакционность:
```
public void DoSomething(int productId)
{
this.Repository.DeleteProduct(productId);
this.Repository.DeleteHistory(productId);
}
Листинг 4. Удаление продукта и истории должно выполняться в одной транзакции
```
Если удаление истории завершается ошибкой, удаление продукта должны быть отменено (по умному это паттерн Unit of Work). Тогда комитить в базу отдельно в методах DeleteProduct и DeleteHistory нельзя. Как же быть? Вы знаете, где искать ответ.
Продолжение следует
-------------------
Мы рассмотрели основной прием внедрения завистей: агрегация, реализованная с помощью внедрения конструктора. Коснулись темы управления временем жизни объектов. До новых встреч. | https://habr.com/ru/post/344380/ | null | ru | null |
# kubernetes, playground, микросервисы и немного магии
В жизни любого DevOps-инженера возникает необходимость создать playground для команды разработки. Как всегда он должен быть умным, шустрым и потреблять минимальное количество ресурсов. В этой статье я хочу рассказать о том, как решал проблему создания такого зверя для микросервисного приложения на kubernetes.
### Входящие условия и требования
Немного о том, что представляет из себя система для которой необходимо было создать playground:
* Kubernetes, bare-metal кластер;
* Простой api-шлюз на базе nginx;
* MongoDB в качестве БД;
* Jenkins в качестве CI-сервера;
* Git на Bitbucket;
* Два десятка микросервисов, которые могут общаться между собой (через api-шлюз), с базой и с пользователем.
Требования, которые мы смогли сформулировать при активном общении с тимлидом:
* Минимизация потребления ресурсов;
* Минимизация изменений в коде сервисов для работы на playground;
* Возможность параллельной разработки нескольких сервисов;
* Возможность разработки нескольких сервисов в одном пространстве;
* Возможность демонстрации изменений заказчикам до деплоя на staging;
* Все разрабатываемые сервисы могут работать с одной БД;
* Минимизация усилий разработчика для разворачивания тестируемого кода.
### Размышления на тему
С самого начала было ясно, что наиболее логичным для создания параллельных пространств в k8s логичнее всего использовать родной инструмент виртуальных кластеров, или в терминологии k8s — namespaces. Задачу, так же, упрощает тот факт, что все взаимодействия внутри кластера производятся по коротким именам предоставляемым kube-dns, что означало, что запуск структуры можно произвести в отдельном namespace без потери связности.
У данного решения есть только одна проблема — необходимость разворачивать в namespace все имеющиеся сервисы, что долго, неудобно и потребляет большое количество ресурсов.
### Namespace и DNS
При создании любого сервиса k8s создаёт DNS-запись вида *..svc.cluster.local*. Данный механизм позволяет общение через короткие имена внутри одного namespace благодаря изменениям вносимым в resolv.conf каждого запускаемого контейнера.
В обычном состоянии он выглядит вот так:
`search .svc.cluster.local svc.cluster.local cluster.local
nameserver 192.168.0.2
options ndots:5`
Т.е к сервису в том же namespace можно обратится по имени , в соседних namespace по имени .
### Обходим систему
В этот момент в голову приходит простая мысль "*База общая, маршрутизацией запросов к сервисам занимается api-шлюз, почему бы не заставить его ходить сначала к сервису в своём namespace, а в случае его отсутствия в default?*"
Да, подобное решение можно было организовать настройками namespace (мы же помним, что это nginx), но подобное решение вызовет разницу в настройках на pg и на прочих кластерах, что неудобно и может вызвать ряд проблем.
Так что, был выбран метод замены строки
`search .svc.cluster.local svc.cluster.local cluster.local`
На
`search .svc.cluster.local svc.cluster.local cluster.local default.svc.cluster.local`
Такой подход обеспечит автоматический переход в namespace default при отсутствии необходимого сервиса в своём namespace.
Подобного результата можно добиться в кластере следующим образом. Kubelet добавляет параметры search в контейнер из resolve.conf хост-машины, так что достаточно просто дописать в /etc/resolv.conf каждой ноды строку:
`search default.svc.cluster.local`
Если же вы не желаете, чтобы ноды ресолвили адреса сервисов, то можно использовать параметр --resolv-conf при запуске kubelet, что позволит указать любой другой файл вместо /etc/resolv.conf. Например файл /etc/k8s/resolv.conf с той же строкой.
### Дело техники
Дальнейшее решение достаточно просто, нужно, только, принять следующие соглашения:
* Новые фичи разрабатываются в отдельных ветках вида play/
* Для работы с несколькими сервисами в рамках одной фичи названия веток должны совпадать в репозиториях всех задействованных сервисов.
* Всю работу по деплою выполняет Jenkins автоматически
* Для тестов фича-ветки доступны по адресу .cluster.local
#### Настройки ssl-offloader
Конфиг nginx для перенаправления запросов к api-gw в соответствующих namespace
```
server_name ~^(?.+)\.cluster\.local;
location / {
resolver 192.168.0.2;
proxy\_pass http://api-gw.$namespace.svc.cluster.local;
}
```
#### Jenkins
Для автоматизации процесса развёртывания используется плагин Jenkins [Pipeline Multibranch Plugin](https://wiki.jenkins.io/display/JENKINS/Pipeline+Multibranch+Plugin).
В настройках проекта указываем собирать только ветки соответствующие шаблону play/\* И добавляем Jenkinsfile в корень всех проектов, с которыми будет работать сборщик.
Для обработки используется groovy-скрипт, целиком приводить его не буду, только пара примеров. Остальной деплой принципиально ничем не отличается от обычного.
Получение имени ветки:
```
def BranchName() {
def Name = "${env.BRANCH_NAME}" =~ "play[/]?(.*)"
Name ? Name[0][1] : null
}
```
Минимальная конфигурация namespace требует развёрнутого api-шлюза, поэтому добавляем вызов проекта создающего namespace и разворачивающего в него api-шлюз:
```
def K8S_NAMESPACE = BranchName()
build job: 'Create NS', parameters: [[$class: 'StringParameterValue', name: 'K8S_NAMESPACE', value: "${K8S_NAMESPACE}"]]
build job: 'Create api-gw', parameters: [[$class: 'StringParameterValue', name: 'K8S_NAMESPACE', value: "${K8S_NAMESPACE}"]]
```
### Заключение
Серебряной пули не существует, но мне так и не удалось найти не только best practices, но и описаний того, как организованы песочницы у других, поэтому решил поделиться методом, который использовал при создании песочницы на базе k8s. Возможно это не идеальный способ, так что с радостью приму замечания или рассказы о том, как данная проблема решена у вас. | https://habr.com/ru/post/338158/ | null | ru | null |
# Перенаправляем printf() из STM32 в консоль Qt Creator
Нередко при отладке ПО микроконтроллера возникает необходимость вывода отладочных сообщений, логов, захваченных данных и прочего на экран ПК. При этом хочется, чтобы и вывод был побыстрее, и чтобы строки отображались не где-нибудь, а прямо в IDE — не отходя от кода, так сказать. Собственно, об этом и статья — как я пытался printf() выводить и отображать внутри любимой, но не очень микроконтроллерной, среды Qt Creator.
В целом, можно придумать огромное количество способов вывода текстовой информации из микроконтроллера. Однако, наиболее часто применяющихся техник не так уж и много:
* [Semihosting](http://www.keil.com/support/man/docs/armcc/armcc_pge1358787046598.htm)
* [Segger RTT](https://habr.com/ru/post/259205/)
* USB-CDC
* UART
* ITM
Semihosting — довольно медленный, RTT — завязан на программно-аппаратные решения Segger\*, USB — есть не в каждом микроконтроллере. Поэтому обычно, я отдаю предпочтение последним двум — использование UART и ITM. О них и пойдёт ниже речь.
\* *Upd. — на самом деле, как подсказывают в комментариях, это не так. Есть варианты как на стороне софта так и железа. Поэтому, из перечисленных способов RTT будет, пожалуй, самым универсальным.*
И сразу некоторое пояснение по тому софту, что будет использоваться далее. В качестве ОС сейчас у меня Fedora 28, а текущей связкой ПО для работы с микроконтроллерами являются:
* [Qt Creator 4.8.1](http://download.qt.io/official_releases/qtcreator) (прямая ссылка на релизы, довольно тщательно спрятанная на сайте)
* [GNU Arm Embedded Toolchain 7](https://developer.arm.com/open-source/gnu-toolchain/gnu-rm/downloads)
* [OpenOCD 0.10.0+dev](http://openocd.org/)
### Перенаправление printf() в GCC
Итак, чтобы в GCC перенаправить вывод printf() необходимо добавить в ключи линкера
```
-specs=nosys.specs -specs=nano.specs
```
Если будет необходим вывод чисел с плавающей запятой, то нужно не забыть ключ
```
-u_printf_float
```
И реализовать функцию \_write(). Например, примерно так
```
int _write(int fd, char* ptr, int len)
{
(void)fd;
int i = 0;
while (ptr[i] && (i < len)) {
retarget_put_char((int)ptr[i]);
if (ptr[i] == '\n') {
retarget_put_char((int)'\r');
}
i++;
}
return len;
}
```
где retarget\_put\_char() — это функция, которая будет загружать символ непосредственно в нужный интерфейс.
### printf() -> ITM -> Qt Creator
Instrumentation Trace Macrocell (ITM) — это блок внутри ядра Cortex-M3/M4/M7, используемый для неинвазивного вывода (трассировки) различного вида диагностической информации. Для реализации printf() об ITM необходимо знать следующее:
* Использует тактовый сигнал TRACECLKIN, частота которого обычно равна частоте работы ядра
* Имеет 32 штуки так называемых stimulus ports для вывода данных
* CMSIS имеет в своем составе функцию ITM\_SendChar(), которая загружает символ в stimulus port 0
* Данные выводятся наружу либо через синхронную шину (TRACEDATA, TRACECLK), либо по асинхронной однопроводной линии SWO (TRACESWO)
* Линия SWO обычно мультиплексирована с JTDO, а значит работает только в режиме отладки по SWD
* Вывод по SWO осуществляется либо с использованием кода Манчестер, либо NRZ (UART 8N1)
* Данные передаются фреймами определенного формата — нужен парсер на приёмной стороне
* Настраивается ITM обычно из IDE или соответствующей утилиты (однако, никто не запрещает настроить в коде программы — тогда вывод в SWO будет работать без поднятой отладочной сессии)
Наиболее удобным способом использования ITM является вывод через SWO с иcпользованием NRZ кодирования — таким образом, нужна всего одна линия, и принимать данные можно будет не только с помощью отладчика со специальным входом, но и обычным USB-UART переходником, пусть и с меньшей скоростью.
Я пошел по пути с использованием отладчика, и был вынужден [доработать](https://habr.com/ru/post/402927/) свой китайский STLink-V2, чтобы он стал поддерживать SWO. Далее всё просто — подключаем JTDO/TRACESWO микроконтроллера к соответствующему пину отладчика, и идём настраивать софт.
В openocd есть команда "tpiu config" — с помощью неё можно настроить способ вывода трассировочной информации (более подробно в [OpenOCD User’s Guide](http://openocd.org/doc/pdf/openocd.pdf)). Так например, использование аргументов
```
tpiu config internal /home/esynr3z/itm.fifo uart off 168000000
```
настроит вывод в файл /home/esynr3z/itm.fifo, использование NRZ кодирования, и рассчитает максимальную скорость передачи, исходя из частоты TRACECLKIN 168 МГц — для STLink это 2МГц. А ещё одна команда
```
itm port 0 1
```
включит нулевой порт для передачи данных.
В состав исходников OpenOCD входит утилита itmdump (contrib/itmdump.c) — с помощью неё можно осуществить парсинг строк из полученных данных.
Чтобы скомпилировать вводим
```
gcc itmdump.c -o itmdump
```
При запуске указываем необходимый файл/pipe/ttyUSB\* и ключ -d1 для того, чтобы выводить полученные байты данных как строки
```
./itmdump -f /home/esynr3z/itm.fifo -d1
```
И последнее. Чтобы отправить символ по SWO, дополняем \_write(), описанный выше, функцией
```
int retarget_put_char(int ch)
{
ITM_SendChar((uint32_t)ch);
return 0;
}
```
Итак, общий план такой: внутри Qt Creator конфигурируем openocd на сохранение всей получаемой информации по SWO в предварительно созданный named pipe, а чтение pipe, парсинг строк и вывод на экран выполняем с помощью itmdump, запущенной как External Tool. Безусловно, существует и более элегантный способ решения поставленной задачи — написать соответствующий плагин для Qt Creator. Однако, надеюсь, что и описанный ниже подход окажется кому-нибудь полезным.
Заходим в настройки плагина Bare Metal (Tools->Options->Devices->Bare Metal).
Выбираем используемый GDB-сервер и добавляем в конец списка команд инициализации строки
```
monitor tpiu config internal /home/esynr3z/itm.fifo uart off 168000000
monitor itm port 0 1
```
Теперь, непосредственно перед тем как отладчик поставит курсор в самое начало main() будет происходить настройка ITM.
Добавляем itmdump в качестве External Tool (Tools->External->Configure...).
Не забываем установить переменную
```
QT_LOGGING_TO_CONSOLE=1
```
для отображения вывода утилиты в консоль Qt Creator (панель 7 General Messages).
Теперь включаем itmdump, активируем режим дебага, запускаем исполнение кода и… ничего не происходит. Однако, если прервать отладку, исполнение itmdump завершится, и на вкладке General Messages появятся все выведенные через printf() строки.
Путём недолгих изысканий было установлено, что строки из itmdump необходимо буферизировать и выводить в stderr — тогда они появляются в консоли интерактивно, во время отладки программы. Модифицированную версию itmdump я залил на [GitHub](https://github.com/esynr3z/openocd-stuff/tree/master/tools/itmdump).
Есть есть еще один нюанс. Отладка при запуске будет зависать на выполнении команды "monitor tpiu config ...", если не будет предварительно запущен itmdump. Происходит это из-за того, что открытие pipe (/home/esynr3z/itm.fifo) внутри openocd на запись — блокирующее, и дебагер будет висеть до тех пор, пока pipe не откроется на чтение с другого конца.
Это несколько неприятно, особенно, если в какой-то момент ITM не будет нужен, но придется вхолостую запускать itmdump, либо постоянно переключать GDB-сервер или удалять/добавлять строки в его настройках. Поэтому пришлось немного поковырять исходники openocd и найти то место, куда нужно подставить небольшой костыль.
В файле src/target/armv7m\_trace.c есть строка с искомой процедурой открытия
```
armv7m->trace_config.trace_file = fopen(CMD_ARGV[cmd_idx], "ab");
```
её нужно заменить на
```
int fd = open(CMD_ARGV[cmd_idx], O_CREAT | O_RDWR, 0664);
armv7m->trace_config.trace_file = fdopen(fd, "ab");
```
Теперь наш pipe будет открываться сразу и не отсвечивать. А значит можно оставить настройки Bare Metal в покое, а itmdump запускать только когда это нужно.
В итоге, вывод сообщений во время отладки выглядит так
printf() -> UART -> Qt Creator
------------------------------
В этом случае всё примерно так же:
* Добавляем в код функцию с инициализацией UART
* Реализуем retarget\_put\_char(), где символ будет отправляться в буфер приемопередатчика
* Подключаем USB-UART адаптер
* Добавляем в External Tools утилиту, которая будет читать строки из виртуального COM-порта и выводить их на экран
Я набросал такую утилиту на C — [uartdump](https://github.com/esynr3z/openocd-stuff/tree/master/tools/uartdump). Использование довольно простое — нужно указать лишь имя порта и баудрейт.
Однако, стоит отметить одну особенность. Работа этой утилиты не зависит от отладки, а Qt Creator не предлагает никаких опций для закрытия запущенных External Tools. Поэтому, для прекращения чтения COM-порта я добавил ещё один внешний инструмент.
Ну и на всякий случай приложу ссылку на шаблон CMake проекта, который фигурировал на скринах — [GitHub](https://github.com/esynr3z/mcu-templates/tree/master/stm32f407vgt6-cmake). | https://habr.com/ru/post/440024/ | null | ru | null |
# C#: Автоматизация Android без посредников (adb)
Всем привет
-----------
Не давно понадобилось автоматизировать одно приложение.Мне не хотелось использовать какие то посредники по типу Appium, во-первых, ресурсы были ограничены, на одном компьютере нужно было заставить работать 3-4 эмулятора, во-вторых с adb работать не так уж и трудно, в-третьих я наткнулся на библиотеку [SharpAdbClient](https://github.com/quamotion/madb), в которой были уже реализованы базовые функции, но самых важных мне не хватало, поэтому пришлось дописать их самому.Я подумал почему бы не сделать библиотеку с расширенным функционалом, поэтому в этой статье будет обзор на библиотеку [AdvancedSharpAdbClient](https://github.com/yungd1plomat/AdvancedSharpAdbClient).
Установка
---------
Вы можете установить библиотеку через nuget, либо через package manager:
```
PM> Install-Package AdvancedSharpAdbClient
```
Так же проект доступен на [github](https://github.com/yungd1plomat/AdvancedSharpAdbClient)
Инициализация
-------------
Для работы библиотеки понадобится [adb.exe](https://developer.android.google.cn/studio/releases/platform-tools?hl=en).Я использовал эмулятор Nox,где adb идёт вместе с приложением и находится по пути Nox\bin\adb.exe.
Первым делом запустим сервер
```
using System;
using AdvancedSharpAdbClient;
namespace AdbTest
{
class Program
{
static void Main(string[] args)
{
if (!AdbServer.Instance.GetStatus().IsRunning)
{
AdbServer server = new AdbServer();
StartServerResult result = server.StartServer(@"F:\Nox\bin\adb.exe", false);
if (result != StartServerResult.Started)
{
Console.WriteLine("Can't start adb server");
return;
}
}
}
}
}
```
Далее нам необходимо создать новый клиент и подключиться к устройству
```
using System;
using System.Linq;
using AdvancedSharpAdbClient;
namespace AdbTest
{
class Program
{
static AdvancedAdbClient client;
static DeviceData device;
static void Main(string[] args)
{
if (!AdbServer.Instance.GetStatus().IsRunning)
{
AdbServer server = new AdbServer();
StartServerResult result = server.StartServer(@"F:\Nox\bin\adb.exe", false);
if (result != StartServerResult.Started)
{
Console.WriteLine("Can't start adb server");
return;
}
}
client = new AdvancedAdbClient();
client.Connect("127.0.0.1:62001"); // Ip Nox'а
device = client.GetDevices().FirstOrDefault(); // Выбираем девайс из подключенных
if (device == null)
{
Console.WriteLine("Can't connect to device");
return;
}
}
}
}
```
Тут я покажу вам лайфхак, как можно автоматически получать Ip эмуляторов.Это пригодится при работе с несколькими эмуляторами одновременно(многопоточность).
Рассмотрим на примере Nox'a, у которого каждый порт начинается с 620, например:
* 127.0.0.1:62001
* 127.0.0.1:62025
* 127.0.0.1:62040
Для поиска можно воспользоваться утилитой **netstat**, которая слушает активные порты и подключения
Получение IP для нескольких эмуляторов
```
static List deviceports = new List();
static string GetIP()
{
while (true)
{
Process[] processes = Process.GetProcessesByName("NoxVMHandle");
foreach (Process process in processes)
{
ProcessStartInfo startInfo = new ProcessStartInfo("cmd", "/c netstat -a -n -o | find \"" + process.Id + "\" | find \"127.0.0.1\" | find \"620\"");
startInfo.UseShellExecute = false;
startInfo.CreateNoWindow = true;
startInfo.RedirectStandardOutput = true;
var proc = new Process();
proc.StartInfo = startInfo;
proc.Start();
proc.WaitForExit();
MatchCollection matches = Regex.Matches(proc.StandardOutput.ReadToEnd(), "(?<=127.0.0.1:)62.\*?(?= )");
foreach (Match match in matches)
{
if (match.Value != "" && !deviceports.Contains(match.Value))
{
deviceports.Add(match.Value);
return "127.0.0.1:" + match.Value;
}
}
}
}
}
```
Так же, если вы хотите работать в многопотоке, в каждом потоке необходимо создавать новый **AdvancedAdbClient** для стабильной работы.
Пример многопоточной работы
```
static ConcurrentQueue deviceports = new ConcurrentQueue(); // Используем потокобезопасный список
static object locker = new object();
static string GetIP()
{
while (true)
{
Process[] processes = Process.GetProcessesByName("NoxVMHandle");
foreach (Process process in processes)
{
ProcessStartInfo startInfo = new ProcessStartInfo("cmd", "/c netstat -a -n -o | find \"" + process.Id + "\" | find \"127.0.0.1\" | find \"620\"");
startInfo.UseShellExecute = false;
startInfo.CreateNoWindow = true;
startInfo.RedirectStandardOutput = true;
var proc = new Process();
proc.StartInfo = startInfo;
proc.Start();
proc.WaitForExit();
MatchCollection matches = Regex.Matches(proc.StandardOutput.ReadToEnd(), "(?<=127.0.0.1:)62.\*?(?= )");
foreach (Match match in matches)
{
if (match.Value != "" && !deviceports.Contains(match.Value))
{
deviceports.Enqueue(match.Value);
return "127.0.0.1:" + match.Value;
}
}
}
}
}
static void Main(string[] args)
{
GetIP();
if (!AdbServer.Instance.GetStatus().IsRunning)
{
AdbServer server = new AdbServer();
StartServerResult result = server.StartServer(@"F:\Nox\bin\adb.exe", false);
if (result != StartServerResult.Started)
{
Console.WriteLine("Can't start adb server");
return;
}
}
// Перед запуском необходимо добавить в Multi Drive 3 эмулятора
for (int i = 0; i < 3; i++) // Запускаем три эмулятора
{
new Thread(() =>
{
Process process = new Process();
process.StartInfo.FileName = @"F:\Nox\bin\Nox.exe";
process.StartInfo.Arguments = $"-clone:Nox\_{i}"; // Запускаем i-тый эмулятор из Multi-Drive
process.Start();
AdvancedAdbClient client = new AdvancedAdbClient();
lock (locker) // Во избежании ошибок
{
client.Connect(GetIP()); // Ip Nox'а
}
DeviceData device = client.GetDevices().FirstOrDefault();
if (device == null)
{
Console.WriteLine("Can't connect to device");
return;
}
}).Start();
}
}
```
Автоматизация
-------------
#### Поиск элемента
Для поиска элемента используется метод **FindElement** и **FindElements**
```
static AdvancedAdbClient client;
static DeviceData device;
static void Main(string[] args)
{
client = new AdvancedAdbClient();
client.Connect("127.0.0.1:62001");
device = client.GetDevices().FirstOrDefault();
Element el = client.FindElement(device, "//node[@text='Login']");
}
```
Можно указать время ожидания элемента (по умолчанию его нету)
```
Element el = client.FindElement(device, "//node[@text='Login']", TimeSpan.FromSeconds(5));
```
```
Element[] els = client.FindElements(device, "//node[@resource-id='Login']", TimeSpan.FromSeconds(5));
```
### Получение атрибута элемента
Каждый элемент содержит свои аттрибуты, для получения необходимо обратиться к полю attributes
```
static void Main(string[] args)
{
...
Element el = client.FindElement(device, "//node[@resource-id='Login']", TimeSpan.FromSeconds(3));
string eltext = el.attributes["text"];
string bounds = el.attributes["bounds"];
...
}
```
### Клик по элементу
Вы можете кликнуть по координатам на экране
```
static void Main(string[] args)
{
...
client.Click(device, 600, 600); // Click on the coordinates (600;600)
...
}
```
Либо же по найденному элементу
```
static void Main(string[] args)
{
...
Element el = client.FindElement(device, "//node[@text='Login']", TimeSpan.FromSeconds(3));
el.Click();// Click on element by xpath //node[@text='Login']
...
}
```
### Свайп
AdvancedSharpAdbClient позволяет свайпнуть от одного элемента к другому
```
static void Main(string[] args)
{
...
Element first = client.FindElement(device, "//node[@text='Login']");
Element second = client.FindElement(device, "//node[@text='Password']");
client.Swipe(device, first, second, 100); // Swipe 100 ms
...
}
```
И так же по координатам
```
static void Main(string[] args)
{
...
device = client.GetDevices().FirstOrDefault();
client.Swipe(device, 600, 1000, 600, 500, 100); // Swipe from (600;1000) to (600;500) on 100 ms
...
}
```
### Ввод текста
Текст может быть абсолютно любым, но учтите, что adb не поддерживает кириллицу.
```
static void Main(string[] args)
{
...
client.SendText(device, "text"); // Элемент должен быть в фокусе
...
}
```
Так же можно автоматически фокусироваться на элементе (кликать, а потом вводить текст)
```
static void Main(string[] args)
{
...
client.FindElement(device, "//node[@resource-id='Login']").SendText("text"); // Автоматически фокусируется
...
}
```
### Очистка поля ввода
Для очистки поля ввода необходимо указать максимальное количество символов в поле
```
static void Main(string[] args)
{
...
client.ClearInput(device, 25); // The second argument is to specify the maximum number of characters to be erased
...
}
```
Автоматически определять длинну текста (может работать неправильно)
```
static void Main(string[] args)
{
...
client.FindElement(device, "//node[@resource-id='Login']").ClearInput(); // Get element text attribute and remove text length symbols
...
}
```
### Отправка нажатия клавиши (keyevent)
Список эвентов вы можете посмотреть [тут](https://developer.android.com/reference/android/view/KeyEvent#constants)
```
static void Main(string[] args)
{
...
client.SendKeyEvent(device, "KEYCODE_TAB");
...
}
```
Команды устройства
------------------
Все команды устройства вы можете посмотреть на страничке [Github](https://github.com/yungd1plomat/AdvancedSharpAdbClient), здесь я покажу лишь 2 главных метода.
### Установка apk
```
static void Main(string[] args)
{
...
PackageManager manager = new PackageManager(client, device);
manager.InstallPackage(@"C:\Users\me\Documents\mypackage.apk", reinstall: false);
manager.UninstallPackage("com.android.app");
...
}
```
### Запуск приложений
```
static void Main(string[] args)
{
...
client.StartApp(device, "com.android.app");
client.StopApp(device, "com.android.app"); // force-stop
...
}
```
Важные ссылки
-------------
[AdvancedSharpAdbClient](https://github.com/yungd1plomat/AdvancedSharpAdbClient) - основная библиотека
[SharpAdbClient](https://github.com/quamotion/madb) - была взята за основу, является форком madb
[madb](https://github.com/camalot/madb) - портированная версия ddmlib с Java
[ddmlib](https://android.googlesource.com/platform/tools/base/+/master/ddmlib/) - оригинальная библиотека для работы с adb
P.S
---
Я не являюсь противником посредников, типа Appium, просто эти фреймворки больше больше подходят для тестирования приложений, а не автоматизации.
Я являюсь только начинающим разработчиком, поэтому прошу строго не судить правильность. кода
Если у вас появились какие либо вопросы, пишите мне на [почту](https://mailto:aynur.musin.06@mail.ru).
Это моя первая статья на Habr, поэтому заранее извиняюсь за косяки. | https://habr.com/ru/post/581252/ | null | ru | null |
# regsrv32.exe на .NET / Register COM server from .NET
Проблема была такая:
У клиента была необходимость переключаться между двумя версиями приложения, которое использует около 1000 com объектов.
Чтобы переключиться надо сделать unreg всем dll первой версии и reg всем dll второй версии… Потом, когда понадобится снова перейти на первую версию, повторить процесс в обратном направлении…
Можно запускать много раз regsrv32.exe, однако, это долго и нетру :) (для каждой dll будет запущенно аж по 2 процесса, на рег и на анрег)…
Поэтому и был написан следующий код. Большой ценности он не представляет, но т.к. поиск в google про реализацию регистрации com сервера на .NET ничего похожего не дал, то привожу его здесь для индексирования и использования теми, кому вдруг надо :)
`// regsrv32 на .NET своими руками. register com server via .net
private void RegDll(string mDll) {
IntPtr pDll = NativeMethods.LoadLibrary(@"path_to_dll\your.dll");
if (pDll == IntPtr.Zero) {
//......
}
IntPtr pDllRegServ = NativeMethods.GetProcAddress(pDll, "DllRegisterServer");
IntPtr pDllUnRegServ = NativeMethods.GetProcAddress(pDll, "DllUnregisterServer");
// check ptrs for zero...
DllFuncServer reg =
(DllFuncServer) Marshal.GetDelegateForFunctionPointer(pDllRegServ, typeof(DllFuncServer));
DllFuncServer unReg =
(DllFuncServer)Marshal.GetDelegateForFunctionPointer(pDllUnRegServ, typeof(DllFuncServer));
int resUnreg = unReg();
int resReg = reg();
bool result = NativeMethods.FreeLibrary(pDll);
Console.Write(resUnreg + " " + resReg);
}
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate int DllFuncServer();
static class NativeMethods {
[DllImport("kernel32.dll")]
public static extern IntPtr LoadLibrary(string dllToLoad);
[DllImport("kernel32.dll")]
public static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName);
[DllImport("kernel32.dll")]
public static extern bool FreeLibrary(IntPtr hModule);
}` | https://habr.com/ru/post/62118/ | null | ru | null |
# Введение в gen_fsm: Банкомат Erlybank
[Предыстория](http://habrahabr.ru/blogs/erlang/55651/)
[Введение в Open Telecom Platform/Открытую Телекомуникационную Платформу(OTP/ОТП)](http://habrahabr.ru/blogs/erlang/55657/)
[Введение в gen\_server: «Erlybank»](http://habrahabr.ru/blogs/erlang/55708/)
Это вторая статья из серии «Введение в OTP». Рекомендую вам [прочитать первую статью](http://habrahabr.ru/blogs/erlang/55708/), в которой говорится о gen\_server и закладываются основы нашей банковской системы перед тем, как читать эту. Если вы быстро схватываете, можете посмотреть [завершенную версию сервера](http://spawnlink.com/otp-intro-1-gen-server-eb-server-withdrawal/) и двигаться дальше.
**Сценарий:** Мы поставили ErlyBank сервер заказчикам, и они остались очень довольны. Но на дворе 21 век, и они хотят также безопасный и простой в использовании банкомат, поэтому они попросили нас расширить наш сервер и создать программное обеспечение для банкомата. Пользовательские аккаунты должны быть защищены 4-цифровым ПИН-кодом. В банкомате можно залогиниться с помощью ранее созданного аккаунта, сделать депозит или снять деньги со счета. Делать красивый интерфейс не требуется, этим занимаются другие люди.
**Цель:** Сначала мы расширим сервер, добавив поддержку ПИН-кода для аккаунтов и авторизации через ПИН-код. Потом мы будем использовать gen\_fsm чтобы создать бэкенд банкомата. Проверка данных будет проводиться на стороне сервера.
#### Что такое gen\_fsm?
[gen\_fsm](http://www.erlang.org/doc/man/gen_fsm.html) — это еще один Erlang/OTP интерфейсный модуль. Он используется для реализации [конечного автомата](http://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D0%B5%D1%87%D0%BD%D1%8B%D0%B9_%D0%B0%D0%B2%D1%82%D0%BE%D0%BC%D0%B0%D1%82).
Я заранее извиняюсь, так как в этой статье понятие «состояние»(state) будет использоваться для обозначения двух вещей:
* **состояние gen\_fsm** — Состояние конечного автомата, текущий «режим» его работы. Оно не имеет ничего общего с состоянием(данными) из gen\_server.
* **состояние(данные)** — Данные состояния сервера — то, о чем вы узнали из предыдущей статьи про gen\_server.
Немного не ловко, конечно, но я постараюсь ссылаться на них только в контексте вышеобозначенных условий.
gen\_fsm начинает работу в некотором состоянии. Любые call/cast вызовы к gen\_fsm обрабатываются в специальных callback-методах, которые должны называться именем текущего состояния gen\_fsm(конечного автомата). Основываясь на произведенном действии, модуль может менять состояние( [текущее состояние, входящий символ] -> новое состояние, прим.). Хрестоматийный пример конечного автомата — это закрытая дверь. В начале дверь находится в состоянии «закрыта». Необходимо ввести 4-значный код, чтобы открыть ее. После ввода 1 цифры дверь сохраняет ее, но одной цифры мало, поэтому она продолжает ждать в состоянии «закрыта». После ввода 4 цифр, если они правильные, дверь меняет состояние на «открыта» на некоторое время. Если цифры не правильные, она остается в состоянии «закрыта» и очищает память. Возможно, сейчас у вас уже появились догадки о том, как мы будем реализовывать конечный автомат с помощью gen\_fsm:)
Так же, как и в случае с gen\_server, представляю список callback-методов, которые должны быть реализованы в gen\_fsm. Вы найдете много общего с gen\_server:
* **init/1** — Инициализирует сервер конечного автомата. Практически идентичен gen\_server.
* **StateName/2** — StateName будет заменено на название состояния. Этот метод вызывается, когда конечный автомат находится в этом состоянии и получает сообщение. В результате, выполняется определенное действие. Это асинхронный callback-метод.
* **handle\_event/3** — То же, что и StateName/2, за исключением того, что этот метод срабатывает, когда клиент вызывает gen\_fsm:send\_all\_state\_event, независимо от текущего состояния автомата. Опять, же асинхронный.
* **StateName/3** — **Синхронная** версия StateName/2. Клиент дожидается ответа сервера.
* **handle\_sync\_event/4** — Синхронная версия handle\_event/3.
* **handle\_info/3** — Эквивалентно gen\_server handle\_info. Этотм метод получает все сообщения, которые были посланы нестандартными средствами gen\_fsm. Это могут быть таймаут-сообщения, process exit сообщения или любые другие сообщения, посланные серверному процессу с помощью "!".
* **terminate/3** — Вызывается, когда сервер завершает работу, в нем вы можете освободить занятые ресурсы.
* **code\_change/4** — Вызывается, когда сервер обновляется в реальном времени. Мы не используем его сейчас, но он будет использоваться в будущих статьях.
#### gen\_fsm скелет
Так же, как и с gen\_server, я начинаю создавать конечный автомат с некоторого общего скелета. Скелет для gen\_fsm можете найти [здесь](http://spawnlink.com/otp-intro-2-gen-fsm-skeleton/).
Там нет ничего экстраординарного. start\_link похож на тот, что мы создали для gen\_server. :) Сохраните скелет, как **eb\_atm.erl**. И вот, мы готовы начать!
#### Расширение eb\_server для создания механизма авторизации аккаунта.
Это еще одно задание, которое, я оставляю вам. Изменения, которые нам необходимы:
1. Теперь при создании аккаунта необходимо требовать ПИН-код, который будет храниться вместе с аккаунтом, без шифрования.
2. Добавить метод authorize/2 с аргументами Name и PIN. Возвращаемые значения должны быть `ok` или `{error, Reason}`.
Также, было бы замечательно требовать ПИН-код при каждой операции депозит/снятие, но, чтобы сэкономить время, а также из-за того, что банк у нас фейковый(мое сердце разбито:( ха!), мы не будем этого делать.
По-честному, это не так-то просто сделать, но если вы учите Erlang сами, вы должны быть достаточно смышленными ;) Так что я думаю, вы можете сделать это! Протестируйте свои изменения перед тем, как продолжать или, по крайней мере, сравните их с ответом внизу.
После внесения изменений ваш eb\_server.erl должен выглядеть [примерно так](http://spawnlink.com/otp-intro-2-gen-fsm-eb-server-authorization/). Обратите внимание, что сообщения, которые вы посылаете серверу могут быть разными, и это нормально. Мышление у всех разное. Очень важно, чтобы API выводил те же данные, правильно. (The important thing is that the API outputs the same data, correctly, англ.)
#### Стратегия проектирования ATM (ATM Design Strategy)
Я хочу взять маленькую «без кода» паузу, чтобы рассказать план работы конечного автомата ATM. Мы собираемся его выполнить в соответствии с диаграммой ниже:
Три голубых блока представляют разные состояния сервера. Стрелки обозначают, какие действия необходимы, чтобы перейти из одного состояния в другое.
#### Инициализация gen\_fsm
Чтобы Запустить ATM, мы используем такой же метод start\_link, как и в gen\_server. Но инициализация немного отличается.
```
init([]) ->
{ok, unauthorized, nobody}.
```
Метод init/1 модуля gen\_fsm должен возвращать `{ok, StateName, StateData}`. StateName — это начальное состояние сервера, а StateData — это начальное состояние(данные) сервера. В нашем случае мы запускаемся в состоянии unauthorized и данные выставляются в `nobody`. Состоянием(данными) будет имя аккаунта, с которым мы работаем, так что сначала там ничего нет. В Erlang нет типа данных null/nil/nothing, вместо которых обычно используется говорящий атом, как у нас nobody, например.
#### Авторизация аккаунта
Теперь нам нужно реализовать API авторизации для ATM. Сначала, определение API:
```
authorize(Name, PIN) ->
gen_fsm:sync_send_event(?SERVER, {authorize, Name, PIN}).
```
Метод sync\_send\_event эквивалентен методу call модуля gen\_server. Он посылает сообщение(вторым аргументом) текущему состоянию сервера(первый аргумент). Поэтому теперь нам надо написать обработчик этого сообщения:
```
unauthorized({authorize, Name, Pin}, _From, State) ->
case eb_server:authorize(Name, Pin) of
ok ->
{reply, ok, authorized, Name};
{error, Reason} ->
{reply, {error, Reason}, unauthorized, State}
end;
unauthorized(_Event, _From, State) ->
Reply = {error, invalid_message},
{reply, Reply, unauthorized, State}.
```
Функция называется unauthorized потому, что она должна получать сообщение, когда сервер находится в состоянии **unauthorized**. Делаем сопоставление с образцом, чтобы обработать тапл `{authorize, Name, Pin}` и используем API методы, экспортированные eb\_server сервером, чтобы авторизировать пользователя.
Если имя пользователя и ПИН-код правильные, мы посылаем `ok` клиенту. Формат ответа: `{reply, Response, NewStateName, NewStateData}`. В соответствии с форматом, мы изменяем состояние в **authorized** и сохраняем имя аккаунта в состоянии(данных).
Если информация по аккаунту была не верной, мы посылаем в ответ error и причину ошибки, состояние и состояние(данные) при этом не меняются.
В конце мы реализуем еще одну «catch-all» функцию. Вам следует делать так всегда, но здесь это *особенно важно*, так как состояния могут получать сообщения, адресованные другим состояниям. Например: что будет, если по какой-то причине кто-либо попытается сделать депозит в неаторизованном состоянии? Нам нужен «catch-all» метод, чтобы послать обратно сообщение об ошибке.
#### Депозит
Как только мы перешли в авторизованное состояние, пользователь собирается сделать депозит или снять деньги со своего банковского аккаунта. Мы реализуем депозит, используя **асинхронный** вызов к серверу. Опять же, это не очень безопасно: мы вообще не проверяем, был ли депозит успешным, но так как наш банк — это фейк, я на это забью. ;)
Итак, в начале, API!
```
%%--------------------------------------------------------------------
%% Function: deposit(Amount) -> ok
%% Description: Deposits a certain amount in the currently authorized
%% account.
%%--------------------------------------------------------------------
deposit(Amount) ->
gen_fsm:send_event(?SERVER, {deposit, Amount}).
```
Все просто, в этот раз мы используем метод `send_event/2` вместо sync\_send\_event. Он посылает асинхронный вызов серверу. А теперь, обработчик…
```
authorized({deposit, Amount}, State) ->
eb_server:deposit(State, Amount),
{next_state, thank_you, State, 5000};
authorized(_Event, State) ->
{next_state, authorized, State}.
```
Опять, все очень просто. Этот метод просто перенаправляет информацию в метод deposit модуля eb\_server, который также проводит всю проверку. Но есть что-то необычное в возвращаемом значении метода deposit! Не только состояние меняется на thank\_you, но еще и это число «5000» там в конце. Это просто *таймаут*. Если не будет получено никакого сообщения в течение 5000 милисекунд(5 секунд), то текущему состоянию пошлется `таймаут-сообщение`.
Которе ведет нас к следующей теме…
#### Короткое «Thank You!» состояние
Многие(или все), кто пользовался банкоматами, знают, что есть такой маленький «Thank You!» экран, который показывается в течение небольшого времени. Вообще-то мы могли спокойно обойтись и без этого экрана в нашей реализации — я просто хотел показать вам фичу с таймаутом в gen\_fsm. После 5000 милисекунд, или если не будет получено никакого сообщения, я меняю состояние на обратно на «unauthorized», и таким образом, ATM может начать работу заново со следующим пользователем. Вот код:
```
thank_you(timeout, _State) ->
{next_state, unauthorized, nobody};
thank_you(_Event, _State) ->
{next_state, unauthorized, nobody}.
```
**Примечание:** Тренированный глаз заметит, что оба метода эквивалентны, и нет необходимости для первого образца. Это правда, я просто включил первый образец, чтобы быть уверенным, что поймаю таумаут.
А здесь законченная на данный момент версия [eb\_atm.erl](http://spawnlink.com/otp-intro-2-gen-fsm-eb-atm-deposits/).
#### Изъятие денег со счета
Снова я оставлю разработку методов для снятия денег как упражнение читателю. Вы можете реализовать эту задачку, как хотите! Просто удостоверьтесь, что ваши реально снимают деньги ;)
Вот [моя версия eb\_atm.erl](http://spawnlink.com/otp-intro-2-gen-fsm-withdrawals/) после реализации механизмов снятия денег со счета. Обратите внимание, что успешная операция перевадит автомат в состояние thank\_you с таймаутом.
#### «Отменить-по-фигу-че»(«Cancel-No-Matter-What») Кнопка
Одна из самых больших проблем компьютеров — это отсутствие кнопки «Отменить», которая прерывала бы все, что вы делаете. И хотя я знаю, что кнопка power off на компьютере справляется с этой задачей на ура, пользователи банкоматов Erlybank лишены такой возможности. Поэтому давайте реализуем cancel метод, который отменял бы все транзакции, вне зависимости от того, в каком вы состоянии находитесь.
Как бы вы реализовали это? В общем, я бы предположил, что вы, основываясь на информации из этой статьи, сделали бы cancel метод, посылающий сообщение `cancel`. Затем, в каждом состоянии вы бы обработали его и вышли бы обратно в `unauthorized` состояние.
Остроумно, но не правильно, но в этом нет вашей вины! Я не указал (или слишком кратко, вы возможно, пропустили это), что есть метод `gen_fsm:send_all_state_event/2`, который послылает сообщение серверу вне зависимости от того, в каком состоянии сервер. Мы используем его, чтобы наш код был [чист](http://en.wikipedia.org/wiki/index.html?curid=4092793).
Наш API:
```
%%--------------------------------------------------------------------
%% Function: cancel/0
%% Description: Cancels the ATM transaction no matter what state.
%%--------------------------------------------------------------------
cancel() ->
gen_fsm:send_all_state_event(?SERVER, cancel).
```
Это сообщение посылается `handle_event/3`, который мы расширяем ниже:
```
handle_event(cancel, _StateName, _State) ->
{next_state, unauthorized, nobody};
handle_event(_Event, StateName, State) ->
{next_state, StateName, State}.
```
Если мы получаем cancel сообщение, сервер переводит состояние в unauthorized и сосяние(данные) в nobody: свеженький ATM!
Как всегда, текущую версию eb\_atm.erl можно посмотреть [тут](http://spawnlink.com/otp-intro-2-gen-fsm-eb-atm-cancel/).
#### Заключительные примечания
В этой статье я показал, как создать простую ATM систему, построенную на конечном автомате, используя [gen\_fsm](http://www.erlang.org/doc/man/gen_fsm.html). Я показал, как обрабатывать сообщения в разных состояниях, менять состояние, менять состояние по таймауту, и «send-to-all» сообщения.
Однако, есть еще немного «бородавок» в нашей системе, и я оставлю вам возможность исправить их. Я подготовил 2 задания для вас, если хотите. Поверьте мне, вы можете их выполнить:
1. Добавить проверку ошибок в операции с депозитом. Заставьте их возвращать `{error, Reason}` и `{ok, Balance}` вместо просто «ok» все время.
2. Добавьте функцию проверки баланса в ATM. Она должна быть доступна только в состоянии authorized и не должна завершать транзакцию. Это означает, что она не должна переводить состояние в thank\_you. Это так потому, что обычно люди, помотрев свой баланс, хотят снять или положить денег себе на счет.
Эти две фичи из упражнений не будут использоваться в будущем, и раз так, я не буду постить ответы здесь. Вы можете проверить себя, заставив их работать! :)
Вторая часть этих статей закончена. Третья статья уже почти готова и будет опубликована в ближайшие дни. Она будет раскрывать тему [gen\_event](http://www.erlang.org/doc/man/gen_event.html). Чтобы поразвлечься, вы можете подумать о том, что я добавлю в Erlybank с помощью gen\_event! :D
Надеюсь, вам понравились эти вводные статьи в Erlang/OTP так же, как и мне понравилось их писать. Спасибо всем за поддержку и удачи! | https://habr.com/ru/post/56196/ | null | ru | null |
# Lock-free структуры данных. Диссекция очереди
Со времени [предыдущего поста](http://habrahabr.ru/company/ifree/blog/219201/) из жизни lock-free контейнеров прошло немало времени. Я рассчитывал быстро написать продолжение трактата об очередях, но вышла заминка: о чем писать, я знал, но реализации на C++ этих подходов у меня не было. «Не годится писать о том, что сам не попробовал», — подумал я, и в результате я попытался реализовать в [libcds](http://libcds.sourceforge.net/) новые алгоритмы очередей.
Сейчас настал момент, когда я могу аргументированно продолжить свой цикл. В данной статье закончим с очередями.
Кратко напомню, на чем я остановился. Были рассмотрены несколько интересных алгоритмов lock-free очередей, а под занавес приведены результаты их работы на некоторых синтетических тестах. Главный вывод — всё плохо! Надежды на то, что lock-free подход на магическом compare-and-swap (CAS) даст нам пусть не линейный, но хотя бы *какой-то* рост производительности с увеличением числа потоков, не оправдались. Очереди не масштабируются. В чем причина?..
Ответ на этот вопрос лежит в особенностях архитектуры современных процессоров. Примитив CAS – довольно тяжелая инструкция, сильно нагружающая кеш и внутренний протокол синхронизации. При активном использовании CAS над одной и той же линией кеша процессор занят в основном поддержкой когерентности кешей, о чем подробнее профессор Paul McKenney ~~с моей помощью~~ уже [писал](http://habrahabr.ru/company/ifree/blog/196548/).
Стеки и очереди — очень недружественные для lock-free подхода структуры данных, так как они имеют небольшое число точек входа. Для стека такая точка только одна — вершина стека, для очереди их две — голова и хвост. CAS конкурирует за доступ к этим точкам, при этом проседает производительность при 100% загрузке процессора, — все потоки чем-то заняты, но только один выиграет и получит доступ к голове/хвосту. Ничего не напоминает?.. Это же классический spin-lock! Получается, при lock-free подходе на CASах мы избавились от внешней синхронизации мьютексом, но получили внутреннюю, на уровне инструкции процессора, и мало что выиграли.
**Ограниченные очереди**Следует отметить, что все вышесказанное относится к неограниченным (unbounded) MPMC (multiple producer/multiple consumer) очередям. В ограниченных (bounded) по числу элементов очередях, которые строятся, как правило, на основе массива, данная проблема может быть не так ярко выражена за счет аккуратного рассредоточения (разброса) элементов очереди по массиву. Также более быстрые алгоритмы могут быть построены для очередей с одним писателем или/и одним читателем.
Проблема эффективной реализации конкурентных очередей интересует исследователей до сих пор. В последние годы усилилось понимание того, что различного рода ухищрения при реализации lock-free очереди «в лоб» не дают ожидаемого результата и следует придумать какие-то другие подходы. Далее мы рассмотрим некоторые из них.
Flat combining
--------------
Этот метод я уже [описывал](http://habrahabr.ru/company/ifree/blog/216013/) в статье о стеке, но flat combining является универсальным методом, поэтому применим и к очереди. Отсылаю читателей к видеозаписи моей [презентации](http://meetingcpp.ru/?p=155) на [C++ User Group, Russia](http://meetingcpp.ru), посвященной как раз реализации flat combining.
**На правах рекламы**Пользуясь случаем, хочу послать лучи поддержки [sermp](https://habrahabr.ru/users/sermp/) — вдохновителю и организатору C++ User Group, Russia. Сергей, твой бескорыстный труд на этом поприще бесценен!
Читателей призываю обратить внимание на данное мероприятие и поддержать его своей явкой, а также, кому есть чем поделиться, презентациями. На своем опыте убедился, что живое общение намного круче, чем даже чтение хабра.
Также обращаю ваше внимание на грядущую [конференцию](http://meetingcpp.ru/?page_id=233) C++Russia 27-28 февраля 2015 в Москве, — приходите!
Массив очередей
---------------
Подход, лежащий на поверхности, но тем не менее довольно трудный для реализации, со множеством подводных камней, предложен в 2013 году в [статье](https://repository.ist.ac.at/124/307/main-spaa2013.pdf) под названием *«Замена конкуренции на сотрудничество для реализации масштабируемой lock-free очереди»*, как нельзя лучше подходящим к теме данного поста.
Идея очень проста. Вместо одной очереди строится массив размером K, каждый элемент которого — lock-free очередь, представленная односвязным списком. Новый элемент добавляется в следующий (по модулю K) слот массива. Тем самым нивелируется толчея на хвосте очереди, — вместо одного хвоста мы имеем K хвостов, так что можно ожидать, что мы получим линейную масштабируемость вплоть до K параллельных потоков. Конечно, нам нужно иметь некий общий атомарный монотонно возрастающий счетчик push-операций, чтобы мультиплексировать каждую вставку в свой слот массива. Естественно, данный счетчик будет единой «точкой преткновения» для всех push-потоков. Но авторы утверждают (по моим наблюдениям, небезосновательно), что инструкция `xadd` атомарного добавления (в нашем случае — инкремента) на архитектуре x86 чуть быстрее, чем CAS. Таким образом, можно ожидать, что на x86 мы получим выигрыш. На других архитектурах атомарный `fetch_add` эмулируется CAS'ом, так что выигрыш будет не так заметен.
Код удаления элемента из очереди аналогичен: имеется атомарный счетчик удаленных элементов (pop-счетчик), на основании которого по модулю K выбирается слот массива. Для исключения нарушения основного свойства очереди — FIFO – каждый элемент содержит дополнительную нагрузку (`ticket`) — значение push-счетчика на момент добавления элемента, фактически — порядковый номер элемента. При удалении в слоте ищется элемент с `ticket` = текущему значению pop-счетчика, найденный элемент и является результатом операции `pop()`.
Интересен способ, которым решается проблема удаления из пустой очереди. В данном алгоритме сначала идет атомарный инкремент счетчика удалений (pop-счетчика), а затем — поиск в соответствующем слоте. Вполне может быть, что слот пустой. Это значит, что пуста и вся очередь. Но ведь pop-счетчик уже инкрементирован, и дальнейшее его использование приведет к нарушению FIFO и даже к потере элементов. Делать откат (декремент) нельзя — вдруг в это же самое время другие потоки добавляют или удаляют элементы (вообще, «назад-отыграть-нельзя» является неотъемлемым свойством lock-free подхода). Поэтому при возникновении ситуации `pop()` из пустой очереди массив объявляется инвалидным, что приводит к созданию нового массива с новыми push- и pop-счетчиками при следующей вставке элемента.
К сожалению, авторы не озаботились (как они пишут, по причине недостатка места) проблемой освобождения памяти, уделив ей лишь несколько предложений с поверхностным описанием применения схемы Hazard Pointer к своему алгоритму. Мне ~~пока~~ не удалось расшифровать их намеки, так что реализации этого интересного алгоритма в библиотеке `libcds` нет. К тому же алгоритм подвержен неограниченному накоплению удаленных элементов в случае, если очередь никогда не пуста, то есть если не происходит инвалидации массива, так как не предусматривается удаления элементов из списка-слота массива. `pop()` просто ищет элемент с текущим `ticket`'ом в соответствующем слоте, но физического исключения элемента из списка не происходит до инвалидации всего массива.
Подытоживая, можно сказать: алгоритм интересный, но управление памятью не описано достаточно четко. Требуется дополнительное изучение.
Сегментированные очереди
------------------------
Другой способ повысить масштабируемость очереди — нарушить её основное свойство first-in – first-out (FIFO). Так ли уж это страшно, зависит от задачи: для некоторых строгое соблюдение FIFO обязательно, для других — в некоторых пределах вполне допустимо.
Конечно, нарушать основное свойство FIFO совсем уж кардинально не хочется, — в этом случае мы получим структуру данных, называемую пулом, в которой не соблюдается вообще никакого порядка: операция `pop()` возвращает *любой* элемент. Это уже не очередь. Для очереди с нарушением FIFO хотелось бы иметь какие-то гарантии этого нарушения, например: операция `pop()` возвратит один из первых K элементов. Для K=2 это значит, что для очереди с элементами A, B, C, D,… `pop()` возвратит A или B. Такие очереди называются *сегментированными* или *K-сегментированными*, чтобы подчеркнуть значение фактора K — ограничения на нарушение FIFO. Очевидно, что для строгой (fair) FIFO-очереди K=1.
Насколько мне известно, впервые простейшая сегментированная очередь подробно рассмотрена в 2010 году в [работе](http://mcg.cs.tau.ac.il/papers/opodis2010-quasi.pdf), посвященной как раз допустимым ослаблениям требований, накладываемых на lock-free структуры данных. Внутреннее строение очереди довольно просто (рисунок из вышеуказанной статьи, K=5):
Очередь представляет собой односвязный список сегментов, каждый сегмент — это массив размером K элементов. `Head` и `Tail` указывают на первый и последний *сегмент* в списке соответственно. Операция `push()` вставляет новый элемент *в произвольный свободный* слот tail-сегмента, операция `pop()` извлекает элемент *из произвольного занятого* слота head-сегмента. При таком подходе очевидно, что чем меньше размер K сегмента, тем менее нарушается свойство FIFO; при K=1 мы получим строгую очередь. Таким образом, варьируя K, мы можем управлять степенью нарушения FIFO.
В описываемом алгоритме каждый слот сегмента может быть в одном из трех состояний: свободный, занят (содержит элемент) и «мусор» (элемент был прочитан из слота). Заметим, что операция `pop()` переводит слот в состояние «мусор», которое *не является* эквивалентом состояния «свободный»: состояние «мусор» является конечным состоянием слота, запись значения в такой слот недопустима. В этом проявляется недостаток алгоритма — слот в состоянии «мусор» нельзя повторно использовать, что приводит к распределению новых сегментов даже в такой типичной для очереди последовательности операций, как чередующийся `push() / pop()`. Этот недостаток был исправлен в [другой работе](http://www.cosy.sbg.ac.at/research/tr/2012-04_Kirsch_Lippautz_Payer.pdf) ценой значительного усложнения кода.
Исследуем
---------
Итак, в libcds появились реализации двух новых алгоритмов для очередей — FCQueue и SegmentedQueue. Посмотрим их перформанс и попробуем понять, стоило ли ими заниматься.
К сожалению, сервер, на котором я гонял тесты для предыдущей статьи, был загружен другими задачами, а впоследствии рухнул. Пришлось прогонять тесты на другом сервере, менее мощном — 2 x 12 core AMD Opteron 1.5ГГц c 64G памяти под управлением Linux, который был практически свободен — idle на уровне 95%.
Я изменил визуализацию результатов — вместо времени выполнения теста по оси Y я теперь откладываю количество мегаопераций в секунду (Mop/s). Напомню, что тест – классический producer/consumer: всего 20 миллионов операций — 10M push и 10M pop без всякой эмуляции payload, то есть тупая долбежка в очередь. Во всех тестах lock-free очередей используется Hazard Pointer для безопасного освобождения памяти.
**Старые данные в новых попугаях**График из предыдущей статьи в новых попугаях — MOp/s, выглядит так
Сначала — лирическое отступление: к чему мы стремимся? Что мы хотим получить, говоря о масштабируемости?
Идеальное масштабирование — линейное увеличение Mop/s при увеличении числа потоков, если железо физически поддерживает такое количество потоков. Реально хорошим результатом будет *какое-то* увеличение Mop/s, более похожее на логарифмическое. Если при увеличении числа потоков мы получаем проседание производительности, то алгоритм является немасштабируемым, или масштабируемым до некоторых пределов.
Результаты для интрузивных очередей (напомню, интрузивный контейнер характеризуется тем, что он содержит указатель на сами данные, а не их копию, как в STL; тем самым не требуется распределять память под копию элементов, что в мире lock-free считается моветоном).
Видно, что Flat Combining реализован не напрасно, — эта техника показывает очень хороший результат на фоне других алгоритмов. Да, увеличения производительности она не дает, но и существенного проседания не видно. Более того, существенным бонусом является то, что она практически не нагружает процессор, — всегда работает только одно ядро. Остальные алгоритмы показывают 100% загрузку ЦП при большом числе потоков.
Сегментированная очередь показывает себя аутсайдером. Быть может, это связано со спецификой реализованного алгоритма: распределение памяти под сегменты (в данном тесте размер сегмента равен 16), невозможность повторно использовать слоты сегмента, что приводит к постоянным аллокациям, реализация списка сегментов на основе boost::intrusive::slist под блокировкой (я пробовал два типа блокировок — spin-lock и std::mutex; результаты практически не отличаются).
Была у меня надежда, что основным тормозом является false sharing. В реализации сегментированной очереди сегмент представлял собой массив указателей на элементы. При размере сегмента равным 16 сегмент занимает 16 \* 8 = 128 байт, то есть две линии кеша. При постоянной толкотне потоков на первом и последнем сегментах false sharing может проявить себя в полный рост. Поэтому я ввел дополнительную опцию в алгоритм — требуемый padding. При указании padding = размеру кеш-линии (64 байт) размер сегмента увеличивается до 16 \* 64 = 1024 байт, но таким образом мы исключаем false sharing. К сожалению, оказалось, что padding практически никак не влияет на производительность SegmentedQueue. Быть может, причина этого в том, что алгоритм поиска ячейки сегмента является вероятностным, что приводит к многим неудачным попыткам чтения занятых ячеек, то есть опять-таки к false sharing. Или же false sharing вовсе не является основным тормозом для данного алгоритма и надо искать истинную причину.
Несмотря на проигрыш, есть одно интересное наблюдение: SegmentedQueue не показывает проседание производительности при увеличении числа потоков. Это вселяет надежду на то, что алгоритмы данного класса имеют какую-то перспективу. Просто надо реализовать их по-другому, более эффективно.
Для STL-like очередей, с созданием копии элемента, имеем похожую картину:
Наконец, просто ради интереса приведу результат bounded queue – алгоритм Дмитрия Вьюкова на основе массива, интрузивная реализация:
При числе потоков = 2 (один читатель и один писатель) эта очередь показывает 32 MOp/s, что не уместилось на графике. При увеличении числа потоков также наблюдаем деградацию производительности. В качестве оправдания можно отметить, что для очереди Вьюкова false sharing также может быть очень существенным тормозящим фактором, но опции, включающей padding по кеш-линии, для неё ещё нет в libcds.
**для любителей странного**Попался мне и необычный Linux-сервер на IBM Power8 — два процессора 3.42 ГГц по десять ядер в каждом, каждое ядро может одновременно выполнять до 8 инструкций одновременно, итого 160 логических процессоров. Вот результаты тех же самых тестов на нем.
Интрузивные очереди:
STL-like очереди:
Как видно, принципиальных изменений не наблюдается. Хотя нет, одно есть — показаны результаты для сегментированной очереди при размере сегмента K=256 — именно это K было для данного сервера близко к наилучшему.
В заключение хочу отметить одно интересное наблюдение. В вышеприведенных тестах для читателей и писателей нет никакой полезной нагрузки (payload), наша цель — просто запихнуть в очередь и прочитать из неё. В реальных задачах какая-то нагрузка всегда есть, — мы что-то делаем с данными, прочитанными из очереди, а перед тем, как поместить в очередь, мы данные готовим. Казалось бы, payload должен приводить к проседанию производительности, но практика показывает, что это далеко не всегда так. Я не раз наблюдал, что payload приводит к существенному росту ~~попугаев~~ MOp/s. Причина, как мне кажется, — разгрузка внутреннего протокола синхронизации кеша, см. ещё раз статью P.McKenney. Вывод напрашивается такой: тестировать надо на реальных задачах.
В этой статье я коснулся малой части работ, посвященных очередям, и только динамическим (unbounded), то есть без ограничения количества элементов. Как я уже говорил, очередь — одна из излюбленных структур данных для исследователей, видимо, потому, что плохо поддается масштабированию. За бортом обзора осталось множество других работ, — об ограниченных (bounded) очередях, work-stealing очередях, применяемых в планировщиках задач, single consumer или single producer очередях — алгоритмы таких очередей существенно заточены на одного писателя или читателя, а потому зачастую проще и/или намного производительнее, — и т.д. и т.п.
**Новости из микромира libcds**За прошедшее с предыдущей статьи время была выпущена версия 1.6.0 библиотеки, в которой помимо реализации техники Flat Combining и SegmentedQueue пофикшено какое-то количество ошибок, существенно переработан SkipList и EllenBinTree.
Репозиторий для грядущей версии 2.0 переехал на [github](http://github.com/khizmax/libcds), а сама версия 2.0 посвящена переходу на стандарт C++11, причесыванию кода, унификации интерфейсов, из-за чего нарушится пресловутая обратная совместимость (что означает, что некоторые сущности будут переименованы), и удалению костылей поддержки старых компиляторов (ну и, как водится, исправлению найденных и генерации новых багов).
Я рад, что мне удалось-таки, несмотря на большой временн*о*й лаг, довести повествование об очередях и стеках до логического конца, ибо это не самые дружественные для lock-free подхода и современных процессоров структуры данных, да и не очень для меня интересные.
Впереди нас ждут куда более увлекательные структуры — ассоциативные контейнеры (set/map), в частности, hash map, с красивыми алгоритмами и, надеюсь, более благодарные в плане масштабируемости.
Продолжение, думаю, воспоследует…
**Lock-free структуры данных**[Начало](http://habrahabr.ru/company/ifree/blog/195770/)
Основы:
* [Атомарность и атомарные примитивы](http://habrahabr.ru/company/ifree/blog/195948/)
* [Откуда пошли быть барьеры памяти](http://habrahabr.ru/company/ifree/blog/196548/)
* [Модель памяти](http://habrahabr.ru/company/ifree/blog/197520/)
Внутри:
* [Схемы управления памятью](http://habrahabr.ru/company/ifree/blog/202190/)
* [RCU](http://habrahabr.ru/company/ifree/blog/206984/)
* [Эволюция стека](http://habrahabr.ru/company/ifree/blog/216013/)
* [Очередной трактат](http://habrahabr.ru/company/ifree/blog/219201/)
* [Диссекция очереди](http://habrahabr.ru/post/230349/)
* [Concurrent maps: разминка](http://habrahabr.ru/post/250383/)
* [Concurrent maps: rehash, no rebuild](http://habrahabr.ru/post/250523/)
* [Concurrent maps: skip list](http://habrahabr.ru/post/250815/)
* [Concurent maps: деревья](https://habrahabr.ru/post/251267/)
* [Итераторы: multi-level array](https://habrahabr.ru/post/314948/)
* [Iterable list](https://habrahabr.ru/post/317882/)
Извне:
* [Введение в libcds](http://habrahabr.ru/company/ifree/blog/196834/) | https://habr.com/ru/post/230349/ | null | ru | null |
# Rsyslog 8. Централизованный сбор логов
Всем добра.
Заканчиваем в этом месяце первый поток [«Администратора Linux»](https://otus.pw/L340/) и запускаем потихоньку второй, который теперь будет заметно переработан и усилен новыми преподавателями. Один из них — [Алексей Цыкунов](https://otus.pw/lECT/), делится сегодня небольшой полезной заметкой.
Поехали.
#### Задача
Есть несколько серверов, на которых крутятся программы, которые сохраняют логи в свои каталоги.
Необходимо централизовано сохранять все эти логи в подкаталогах по имени серверов, сохраняя названия файлов.
Возможности перенастроить программы для записи логов сразу в syslog нет.
Окружение:
* server — centos7
* client — centos6
И на клиенте и на сервере необходимо обновить rsyslog до последней версии.
```
cd /etc/yum.repos.d/
wget http://rpms.adiscon.com/v8-stable/rsyslog.repo
yum update rsyslog
```
#### Решение
Rsyslog имеет следующие стандартные модули:
* imfile — чтение из файла
* omfwd — перенаправление (например, в сеть)
* imtcp — чтение из сети по tcp
* omfile — запись в файл, встроенный модуль
С помощью них произведен настройку на клиентских машинах и сервере:
#### На клиенте
```
module(load="imfile" mode="inotify")
# настраиваем темплейт для строки лога
template (name="LongTagForwardFormat" type="string"
string="<%PRI%>%TIMESTAMP:::date-rfc3339% %HOSTNAME% %syslogtag%%$.suffix%%msg:::sp-if-no-1st-sp%%msg%")
# настраиваем правило для пересылки
ruleset(name="sendToLogserver") {
action(type="omfwd" Target="192.168.1.1" Port="514" protocol="tcp" Template="LongTagForwardFormat")
}
# правило для чтения файлов. обязательно наличие тэга
input(type="imfile"
File="/your_app_path_logs/log/*.log"
tag="apptag__"
ruleset="app_logs"
addMetadata="on")
# установка суффикса из имени лога, имя лога
ruleset(name="app_logs") {
set $.suffix=re_extract($!metadata!filename, "(.*)/([^/]*)", 0, 2, "app.log");
call sendToLogserver
}
```
#### На сервере
На сервере я конфигурил непосредственно /etc/rsyslog.conf
```
# модуль работы с unix socket
module(load="imuxsock")
# модуль работы с journald
module(load="imjournal")
# наш модуль для сбора данных по сети
module(load="imtcp" MaxSessions="500")
# активация модуля с назначением правил
input(type="imtcp" port="514" ruleset="remote")
# темплейт для динамической записи в папку с именем хоста и с именем файла, соответствующему имени файла на клиенте
template(name="RemoteHost" type="string" string="/opt/pabkss/%HOSTNAME%/%$.logpath%")
# темплейт для записи изначального текста
template(name="OnlyMsg" type="string" string="%msg:::drop-last-lf%\n")
# непосредственно правила обработки
ruleset(name="remote") {
# разбираем наши логи, выстраиваем правильный путь
set $.logpath = replace($programname, "__", "/");
action(type="omfile"
dynaFile="RemoteHost" template="OnlyMsg")
}
```
#### Возникающие проблемы
* использование одинарных кавычек
* при наличие каких то ошибок в синтаксисе при перезапуске на сервере, отображает корректный статус, но по факту не работает. Будьте внимательны, портит много нервов.
```
systemctl restart rsyslog
```
#### THE END
Как всегда ждём комментарии, вопросы тут или можно заглянуть на [открытый урок](https://otus.pw/Avh9/) и помучать преподавателей там. | https://habr.com/ru/post/352682/ | null | ru | null |
# Практический опыт работы с Bitmap средствами Android
Не так давно по долгу службы я столкнулся с одной задачей: нужно было придумать и реализовать дизайн медиа-плеера для Android. И если продумать и организовать более или менее сносное размещение элементов управления и информации оказалось делом не хитрым, то чтобы привнести в дизайн какую-то изюминку, пришлось хорошенько подумать. К счастью, в запасе у меня был такой элемент, как картинка с обложкой альбома проигрываемой мелодии. Именно он должен был добавить красок всей картинке.
Однако, будучи просто выведенной среди кнопок и надписей, обложка выглядела бумажным стикером, наклеенным на экран. Я понял, что без обработки изображения здесь не обойтись.
Некоторые раздумья насчёт того, что можно было бы тут придумать увенчались решением сделать для изображения обложки эффект отражения и тени. Сразу оговорюсь, что практическая реализация отражения не является моей оригинальной идеей. Её я подсмотрел в найденной англоязычной [статье](http://www.inter-fuser.com/2009/12/android-reflections-with-bitmaps.html). В настоящем посте я лишь хочу привести некоторое осмысление производимых над изображением манипуляций, свои дополнения к процессу обработки и отметить некоторые нюансы работы с Bitmap в Android.
Итак, на входе я имел Bitmap с картинкой. Для начала я создал пустой Bitmap размером с оригинальную картинку, который позже должен был стать той же обложкой, но с нанесённой на неё тенью.
```
width = sourceBitmap.getWidth();
height = sourceBitmap.getHeight();
Bitmap gradCover;
try {
gradCover = Bitmap.createBitmap(width, height, config);
} catch (OutOfMemoryError e) {
gradCover = null;
}
```
Этот метод создаёт изменяемый (что важно) Bitmap.
Здесь обязательно нужно отметить, что при работе с Bitmap'ами необходимо внимательно следить за памятью. Придётся ловить исключения. И ещё один момент: изучение профайлером показало, что перед вызовом метода createBitmap() работает сборщик мусора. Учтите это, если в вашем приложении скорость работы критична.
Далее я создал холст и нанёс на него исходное изображение.
```
Canvas canvas = new Canvas(gradCover);
canvas.drawBitmap(sourceBitmap, 0, 0, null);
//Free up memory, associated with the original bitmap
sourceBitmap.recycle();
```
В этом месте отмечу, что всегда, как только Bitmap становится не нужен, его нужно уничтожать методом recycle(). Дело в том, что объект этого типа представляет собой всего лишь ссылку на память с самим изображением и выглядит для сборщика мусора очень маленьким (хотя на самом деле памяти занято много). Это может привести к тому, что память закончится в самый неподходящий момент.
После всей подготовки я нанёс на холст краску с тенью.
```
Paint paint = new Paint();
int[] colors = {0xffffffff, 0xffffffff, 0xb0c0c0c0, 0xb0c0c0c0};
float radius = (((float) width * (float) width) / 4 + (float) height * (float) height) / ((float) width);
int fullRadius = (int) (1.92 * radius);
float[] positions = {0, 0.499f, 0.511f, 1};
RadialGradient shader = new RadialGradient((width - radius), 0, fullRadius, colors, positions, Shader.TileMode.CLAMP);
paint.setShader(shader);
paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));
canvas.drawRect(0, 0, width, height, paint);
int[] linColors = {0x00ffffff, 0xffffffff, 0xff000000, 0x00000000};
float[] linPositions = {0, 0.03f, 0.97f, 1};
LinearGradient vertical = new LinearGradient(0, 0, 0, height, linColors, linPositions, Shader.TileMode.CLAMP);
paint.setShader(vertical);
paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));
canvas.drawRect(0, 0, width, height, paint);
LinearGradient horizontal = new LinearGradient(0, 0, width, 0, linColors, linPositions, Shader.TileMode.CLAMP);
paint.setShader(horizontal);
paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));
canvas.drawRect(0, 0, width, height, paint);
```
RadialGradient в моём случае представляет тень, падающую по полукругу из правого верхнего угла изображения в центр нижней грани. Ему нужно установить центр (может выходить за пределы картинки), радиус, последовательность цветов и расстояния от центра по радиусу для каждого цвета. Для тени использовалось изменение альфы в цветах на радиусе.
LinearGradient использовался для фэйда краёв картинки. Его применение очень похоже на RadialGradient. Нужно задать начало и конец линии, вдоль которой пойдёт градиент, цвета и их позиции на этой линии.
Наконец, я приступил к рисованию отражения. К этому моменту у меня уже был Bitmap с нанесёнными тенями gradBitmap. Опять надо было создавать холст, создавать пустое изображение (на этот раз на треть длиннее оригинального), помещать его на холст и наносить на верх него Bitmap с тенями.
```
Bitmap refCover = Bitmap.createBitmap(width, height + height / 3, Bitmap.Config.ARGB_8888);
Canvas refCanvas = new Canvas(refCover);
refCanvas.drawBitmap(gradCover, 0, 0, null);
```
После недолгих приготовлений начиналось самое интересное. Я создал матрицу, переворачивающую изображение снизу вверх. С её помощью создал Bitmap из трети исходного и нанёс его на холст под оригинальным изображением.
```
Matrix matrix = new Matrix();
matrix.preScale(1, -1);
Bitmap reflectionImage = Bitmap.createBitmap(gradCover, 0, 2 * height / 3, width, height / 3, matrix, false);
refCanvas.drawBitmap(reflectionImage, 0, height, null);
reflectionImage.recycle();
```
Кстати, краткое замечание: в классе Bitmap существует несколько методов createBitmap, и лишь один из них создаёт изменяемые Bitmap'ы, на которых можно рисовать. Остальные для рисования НА них не годятся.
И наконец, нанесение прозрачного градиента для придания эффекта отражения.
```
Paint refPaint = new Paint();
LinearGradient refShader = new LinearGradient(0, height, 0, height + height / 3, 0xc0ffffff, 0x00ffffff, Shader.TileMode.CLAMP);
refPaint.setShader(refShader);
refPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));
refCanvas.drawRect(0, height, width, refCover.getHeight() + height, refPaint);
```
Краска наносится на ту часть рисунка, которая является отражением.
Всё. Я получил refCover — Bitmap, на котором изображена обложка альбома с тенью, сглаженными краями и отражением.
P.S. В данной статье для меня был важен не сам факт достижения визуальных эффектов, а способы их получения и нюансы, с ними связанные. Если для кого-то вещи, описанные здесь, очевидны — прекрасно. Всем остальным, я надеюсь, статья поможет в написании своих приложений под Android.
UPD: картинки ДО и ПОСЛЕ
  | https://habr.com/ru/post/107757/ | null | ru | null |
# Сортировка изображений по разрешению с помощью Ruby и RMagick
Доброго времени суток. Читая хабр, я наткнулся на статью [«Сортировка изображений по разрешению с помощью Python и PIL»](http://habrahabr.ru/blogs/python/85306/) (позднее появилась статья [«Сортировка изображений по разрешению… на сцене PowerShell»](http://guderian.habrahabr.ru/blog/85576/) ), почитал комментарии и захотелось написать что-то подобное на Ruby.
Прошу не судить меня, а только критиковать! На самом деле только недавно начал изучать Ruby, а точнее это моя первая программа, так что любые найденные ошибки будут только на пользу. Программа написана на Ruby с использованием библиотеки RMagick. Как работает программа:
1) Пользователь вводит путь к директории с картинками (jpg,png,gif расширяется элементарно — (jpg|png|gif|другие форматы)
2) Потом путь к папке, в которой будут созданы поддиректории с именем равным разрешению картинок.
3) Далее программа «бегает» рекурсивно по директориям с картинками, найдя файлы с расширением jpg|png|gif, определяется разрешение и проверяется наличие директории с соответствующим разрешением в названии, если такой нет — создает.
4) Копирует файл, считает количество копированных файлов.
Код на Ruby выглядит немного красивее — мое мнение. Думаю, некоторым людям будет интересно сравнить аналогичный код Ruby и Python, вот только в моей программе копирование файлов вместо перемещения.
Что не сделано: проверка на существование копируемого файла и в случае существования – переименовывание.
> `Copy Source | Copy HTML1. require 'find'
> 2. require 'fileutils'
> 3. require 'RMagick'
> 4.
> 5.
> 6. def image\_sort(unsort\_path, sort\_path)
> 7. count = 0
> 8. if !File.directory?(sort\_path)
> 9. FileUtils.mkdir sort\_path
> 10. end
> 11. if File.directory?(unsort\_path)
> 12. Find.find(unsort\_path) { |fname|
> 13. if /\.(jpg|png|gif)$/i =~ fname
> 14. count += 1
> 15. img = Magick::Image::read(fname).first
> 16. wh\_dir\_name = img.columns.to\_s + 'x' + img.rows.to\_s
> 17. if !File.directory?(sort\_path + wh\_dir\_name)
> 18. FileUtils.mkdir sort\_path + wh\_dir\_name
> 19. end
> 20. FileUtils.cp(fname, sort\_path + wh\_dir\_name)
> 21. puts fname + ' copied'
> 22. end
> 23. }
> 24. else
> 25. puts unsort\_path + ' not found'
> 26. end
> 27. puts **count**.to\_s + ' file(s) copied'
> 28. end
> 29.
> 30. puts 'Path to pictures: '
> 31. pd = gets
> 32. pd.chomp!
> 33. puts 'Path to new sort directory: '
> 34. sd = gets
> 35. sd.chomp!
> 36. image\_sort( pd, sd )`
Результат:
Так получилось, что картинки для теста имели разный размер. | https://habr.com/ru/post/85609/ | null | ru | null |
# Веская причина для проверки ваших зависимостей: AGPL-edition
Вот вы берёте код под лицензиями BSD, MIT и Apache2 и в ус не дуете, а потом – бац! – вторая смена, и в транзитивной зависимости рисуется код под AGPL. Мы стараемся следить за этим и предпочитаем скорее перебдеть, чем недобдеть.
Прежде чем добавить в любой из своих проектов новые зависимости, я всегда делаю базовую проверку. Что я проверяю (стандартный чеклист):
* Под какой лицензией выпущен код?
* Кто автор?
* Есть ли какие-то серьёзные нерешённые проблемы в трекере ошибок?
* Ведётся ли история серьёзных багов в трекере ошибок?
* Каким образом происходит код-ревью для пулреквестов?
После этого я бегло просматриваю сам код в поисках чего-то явно небезопасного или вредоносного. Это нужно, чтобы почувствовать качество самой кодовой базы. Далее я пытаюсь найти [«коричневые M&Ms»](https://www.entrepreneur.com/article/232420) – незначительные детали, которые могут указывать на большие проблемы. И рекурсивно повторяю всё вышесказанное с транзитивными зависимостями. Кроме того, я ещё раз бегло просматриваю код каждый раз, когда обновляю зависимость.
Это довольно большой объём работы, но она необходима, чтобы не стать жертвой атак типа [event-stream](https://blog.npmjs.org/post/180565383195/details-about-the-event-stream-incident). А недавно мне напомнили ещё об одной веской причине для проверки зависимостей. В тот момент я делал ревью [активно рекламируемой библиотеки](https://webauthn.io) от Duo для WebAuthn на Go, она лежит тут: [github.com/duo-labs/webauthn](https://github.com/duo-labs/webauthn).
Всё началось с того, что я заметил несколько «коричневых M&M's»:
* Данные логировались в stdout, несмотря на то, что это библиотека.
* Код был с запашком.
Конечно же, эти мелкие проблемы были лишь предвестниками чего-то большего: когда я начал ревью одной из транзитивных зависимостей ([github.com/katzenpost/core/crypto/eddsa](http://github.com/katzenpost/core/crypto/eddsa)), меня встретил заголовок [лицензии AGPLv3](https://github.com/katzenpost/core/blob/d5cf686c5a7811418262be381d27b43c1fea2e6c/crypto/eddsa/eddsa.go#L1-L15).
Это плохая новость для тех, кто хочет использовать библиотеку WebAuthn от Duo. Несмотря на то, что Duo лицензировал свою библиотеку под BSD, выбирая её, вы также связываете своё приложение с библиотекой AGPL. А, по мнению (A)GPL, таким образом вы создаёте «модифицированный» продукт, попадающий под правила [раздела 13 AGPL](https://www.gnu.org/licenses/agpl-3.0.en.html#section13):
> Если вы вносите изменения в программу, ваша изменённая версия должна явно предлагать всем пользователям, взаимодействующим с ней удалённо через сеть (если ваша версия поддерживает такое взаимодействие), возможность получить бесплатный свободный доступ к исходному коду вашей версии с помощью стандартных средств копирования программного обеспечения (несмотря на любые другие положения настоящей Лицензии).
Другими словами, если вы использовали [github.com/duo-labs/webauthn](http://github.com/duo-labs/webauthn) в общедоступном web-приложении, теперь ваше web-приложение должно быть с открытым исходным кодом.
Самая возмутительная вещь об этой зависимости заключается в том, что она дублирует [golang.org/x/crypto/ed25519](https://godoc.org/golang.org/x/crypto/ed25519) – одну из [квазистандартных «х» библиотек](https://github.com/golang/go/wiki/SubRepositories) Go.
По факту [github.com/duo-labs/webauthn](http://github.com/duo-labs/webauthn) – это то же самое, что и первоначально используемая [golang.org/x/crypto/ed25519](http://golang.org/x/crypto/ed25519). Подмена произошли во время пулреквеста внешней коллаборации под названием [«Consolidate COSE things to their own area»](https://github.com/duo-labs/webauthn/pull/25). В процессе переноса части кода из одного файла в другой этот пулреквест незаметно изменил реализацию `OKPPublicKeyData.Verify`.
Вот `OKPPublicKeyData.Verify`, который использует [golang.org/x/crypto/ed25519](http://golang.org/x/crypto/ed25519):
```
// Verify Octet Key Pair (OKP) Public Key Signature
func (k *OKPPublicKeyData) Verify(data []byte, sig []byte) (bool, error) {
f := HasherFromCOSEAlg(COSEAlgorithmIdentifier(k.PublicKeyData.Algorithm))
h := f()
h.Write(data)
return ed25519.Verify(k.XCoord, h.Sum(nil), sig), nil
}
```
А вот `OKPPublicKeyData.Verify`, который использует AGPL-лицензированный [github.com/katzenpost/core/crypto/eddsa](http://github.com/katzenpost/core/crypto/eddsa):
```
// Verify Octet Key Pair (OKP) Public Key Signature
func (k *OKPPublicKeyData) Verify(data []byte, sig []byte) (bool, error) {
f := HasherFromCOSEAlg(COSEAlgorithmIdentifier(k.PublicKeyData.Algorithm))
h := f()
h.Write(data)
var oKey eddsa.PublicKey
err := oKey.FromBytes(k.XCoord)
if err != nil {
return false, err
}
return oKey.Verify(h.Sum(nil), sig), nil
}
```
Этому изменению не было дано никакого объяснения. Ревью пулреквеста провели [два сотрудника](https://github.com/duo-labs/webauthn/pull/25#issuecomment-472051532) Duo, одобрили его и смержили.
Именно поэтому мне не нравится принимать запросы на пулреквесты, которые перемещают код. Даже если новая организация кода лучше прежнего, затраченное время на проверку «не делает ли новый пулреквест чего-нибудь лишнего» съедает слишком много времени.
Я [разместил предупреждение](https://github.com/duo-labs/webauthn/issues/56) о зависимости библиотеки с лицензией AGPL, и разработчики [вернули обратно](https://github.com/duo-labs/webauthn/pull/58) [golang.org/x/crypto/ed25519](http://golang.org/x/crypto/ed25519). Несмотря на это, я решил не использовать [github.com/duo-labs/webauthn](http://github.com/duo-labs/webauthn). Основная часть библиотеки и её зависимостей предназначена для поддержки WebAuthn misfeature под названием attestation, которую у меня есть меньше, чем нулевое желание использовать. Я только что закончил писать значительно более простую, свободную от attestation библиотеку, и по размеру она меньше, чем одна десятая от вышеупомянутой. Скоро я открою её исходный код. Разработка этой библиотеки вышла дешевле, чем ответственность за использование существующей WebAuthn Go библиотеки.
Этот случай напомнил мне, почему мне нравится программирование на Go. Благодаря обширным стандартным и квазистандартным «х» библиотекам Go, в моих проектах обычно мало дополнительных зависимостей. А хорошая репутация и операционные процедуры Go позволяют мне не париться и не заниматься перепроверкой исходного кода компилятора и стандартных библиотек. И, несмотря на то, что я люблю Rust, я прихожу в ужас каждый раз, когда смотрю на дерево зависимостей их типичных библиотек: обычно я вижу десятки транзитивных зависимостей, написанных непонятными рандомными чуваками из интернета, которым у меня нет никаких оснований доверять. Проверка всех этих зависимостей занимает слишком много времени, поэтому я гораздо менее продуктивен в Rust, чем Go.
Последнее замечание: как поклонник проверяемых структур данных, таких как Прозрачность сертификатов (Certificate Transparency), я должен любить новую базу данных [Go checksum database](https://go.googlesource.com/proposal/+/master/design/25530-sumdb.md). Однако checksum database не принесёт вам никакой пользы, если вы не потратите время на проверку своих зависимостей. К сожалению, я уже видел одного чрезмерно увлечённого пользователя Go, утверждающего, что checksum database решает все проблемы с управлением зависимостями. Но это не так. Нет никаких простых способов, чтобы от этого избавиться, и вам нужно смириться с фактом: время от времени нужно делать ревью зависимостей в ваших проектах. | https://habr.com/ru/post/484898/ | null | ru | null |
# How to save energy with BARY: Smart Home
Well, every modern person has at least once wondered: for how much longer can you pay such huge utility bills?! I am no exception. Electricity, gas, heating, water, rent, elevator, removal of solid waste, etc. etc.
One of the reasons (far from the last) of creating the BARY application was the ability to collect statistics, analyze and reduce energy consumption. Europe has long passed into the regime of total economy; I think this fate will not bypass us. Therefore, to prepare for this in advance definitely will not be superfluous.
I now propose that we examine how we managed to optimize the cost of electricity along with BARY: Smart Home.
Getting started: air conditioning and under floor heating
=========================================================
The first optimization of energy costs was to restore order in the use of underfloor heating and air conditioning. Even without a detailed analysis, it was clear that they consume a lot.
Today, only the lazy did not write about the prevention of viral infections. But, nevertheless, practice makes perfect. The key to healthy antiviral weather in the apartment is a temperature of 18-24 C, humidity 40-60%, as well as regular ventilation.
I almost did not turn the air conditioning off during the summer. In winter, the same thing happened with warm floors. At the time when the owner was absent from the house, air conditioning turned off only occasionally (we did not want to return to the stuffy room) and the floor heating never went down. The bills for all this were quite cosmic, and the temperature was far from ideal parameters. It was somehow impossible to turn everything off manually before leaving: either we had no time, or it was simply forgotten.
Most household air conditioners do not have remote air temperature sensors (this is my case), i.e. they do not accurately provide the specified temperature regime. But they can be turned on by any external sensor when the upper temperature threshold is reached and turned off when it reaches the lowest. This was my first automation.
In fact, it goes like this: the lower threshold is set at 24.0 ° C and the upper — 24.5 ° C. As soon as the temperature in the apartment rises above 24.5 ° C, the air conditioner turns on and works until the temperature drops below 24.0 ° C. To prevent the conditioner from turning on and off every minute, a condition is set for the minimum time for work and rest. I have it for 10 minutes. The value was selected empirically. In practice, the temperature has always been in the indicated range.
In BARY, it looks like this:
*Fig. The rule of turning on the air conditioner*
I think it’s worthwhile to dwell in more detail on what the rule shown in the example does:
* The condition of the air conditioner has not been changed over the past 10 minutes;
* Armed mode is off;
* Air conditioning off;
* Sleep mode is off (in night mode another rule is used);
* The temperature in the living room or in the kitchen exceeds the value set in these rooms (I have a studio apartment; therefore I use a sensor in each room. You can use either a numerical value or variables from the settings of zones and rooms as values);
* A motion sensor in the kitchen does not detect movement (this sensor is used by the wife, because she does not like it when the air conditioning is blowing on her);
* There is no energy consumption for the water heater (it is very voracious, and at the time of its operation it is better not to turn on anything ‘heavy’).
Since this moment, the consumption of electricity by the air conditioner decreased several times. In order for the air conditioner would not work idle when there are no hosts, a virtual button was made in BARY, the status of which was present in the automation of the air conditioner (“Security” from the example above). The same virtual button was for night mode (“Sleep” from the example above), which was also taken into account in a separate automation rule and turned on the air conditioner in the most silent mode. At first, these buttons had to be activated manually.
The automation solution was found in the form of Apple ecosystem. A bunch of my devices were implemented with Homekit, and also Apple TV was acquired. With it, you can implement the work of automation rules in Homekit (you can also use iPad, but I didn’t have it at that time). The rules are created in Homekit itself: the last person leaves home; the first person comes home. Virtual buttons were bound to these rules in BARY.
 
*Fig. Rules for automatic security on / off*
At first I even kept statistics, which displayed the number of minutes worked by the air conditioner per hour. Unfortunately, now the statistics have already been lost, but the air conditioner’s operating time has decreased by almost ⅔ from the original figure.
Identification of the main electricity consumers
================================================
### Analysis methods for the major consumers
In order to start optimizing costs, you need to understand where the majority of the electricity goes.
Here, I think, there may be different approaches:
* The usage of special modules — relays. In addition to their main on / off function, they keep track of the energy that is consumed by the devices connected to them;
* Applying special meters using current transformers;
* Measuring the power consumption by ourselves (for example, using a wattmeter) and indicating the average value in BARY (this method is completely inaccurate, but it will work out approximate indications).
For all devices except the under-floor heating, I have installed: overhead sockets from Blitzwolf, modules for Shelly 1pm / Aqara Relay Module / Fibaro Double Switch 2 socket boxes. Maybe there was something else, I don’t remember now.
For the under-floor heating, I took readings based on the status of their work and average consumption indicators (the third, not very accurate way).
In the device settings there is a special field for indicating energy consumption (consumer power):
*Fig. Configuring the device’s energy consumption parameters*
The total power consumption was taken from the input counter using the Wemos D1 board and a simple sketch:
**The source code for this sketch**
```
#include
#include
#include
#include
#include
#define WIFI\_SSID "\*\*\*\*"
#define WIFI\_PASS "\*\*\*\*"
#define API\_URL "http://192.168.1.33/api/post-data"
volatile unsigned int state = 0;
volatile unsigned int kWh = 0;
volatile unsigned int blinked = 0;
int impulse = 3200;
int eeAddress = 0;
unsigned int lastMillis = 0;
int counter = 0;
int blinkMin = 10;
int timeout = 15000;
int PIN = D8;
void setup()
{
state = impulse;
EEPROM.begin(512);
counter = EEPROM.read(eeAddress);
EEPROM.write(eeAddress, counter + 1);
EEPROM.commit();
pinMode(PIN, INPUT\_PULLUP);
attachInterrupt(digitalPinToInterrupt(PIN), blink, RISING);
Serial.begin(115200);
Serial.println(F(" "));
connectWiFi();
}
void connectWiFi()
{
WiFi.begin(WIFI\_SSID, WIFI\_PASS);
while (WiFi.status() != WL\_CONNECTED) {
delay(500);
Serial.println("WiFi: Waiting for connection");
}
Serial.println("WiFi: connected");
}
float roundEx(float value, int digits)
{
int newValue = value \* pow(10, digits);
return (float) newValue / pow(10, digits);
}
void loop()
{
if (blinked >= blinkMin && millis() - lastMillis > timeout) {
float divider = (float) impulse \* (millis() - lastMillis) / 1000 / 3600;
float power = blinked / divider;
float kWhFloat = kWh + (float) (impulse - state) / impulse;
Serial.print(F("sec="));
Serial.print(millis() / 1000);
Serial.print(F("; time="));
Serial.print((millis() - lastMillis) / 1000);
Serial.print(F("; blinkMin="));
Serial.print(blinked);
Serial.print(F("; state="));
Serial.print(state);
Serial.print(F("; kWh="));
Serial.print(kWhFloat, 3);
Serial.print(F("; power="));
Serial.print(power, 3);
Serial.println(F(" "));
blinked = 0;
lastMillis = millis();
if (WiFi.status() == WL\_CONNECTED) {
StaticJsonBuffer<300> JSONbuffer;
JsonObject& JSONencoder = JSONbuffer.createObject();
JSONencoder["device"] = "main\_counter";
JSONencoder["function"] = "counter";
JSONencoder["counter"] = counter;
JSONencoder["power"] = power;
JSONencoder["usage"] = kWhFloat;
char JSONmessageBuffer[300];
JSONencoder.prettyPrintTo(JSONmessageBuffer, sizeof(JSONmessageBuffer));
Serial.println(JSONmessageBuffer);
HTTPClient http;
http.begin(API\_URL);
http.addHeader("Content-Type", "application/json");
int httpCode = http.POST(JSONmessageBuffer);
String payload = http.getString();
Serial.print(httpCode);
Serial.print(" ");
Serial.println(payload);
http.end();
} else {
connectWiFi();
}
}
}
void blink()
{
detachInterrupt(digitalPinToInterrupt(PIN));
attachInterrupt(digitalPinToInterrupt(PIN), lowInterrupt, FALLING);
state--;
if (state == 0 || state > impulse) {
kWh++;
state = impulse;
}
blinked++;
}
void lowInterrupt(){
detachInterrupt(digitalPinToInterrupt(PIN));
attachInterrupt(digitalPinToInterrupt(PIN), blink, RISING);
}
```
Any electric meter has a pulse output, which is duplicated by LED. When the LED blinks- the pulse has passed. If you connect a device, such as an Arduino, to the pulse output, you can calculate the number of pulses. A sketch every 15 seconds (but not more often than it accumulates a sufficient number of pulses) makes a POST request with the current readings in BARY (Why the device itself creeps onto the server, and not vice versa? I don’t remember, at that moment it seemed convenient). Pulses are read by interruptions, and the strange “attach / detach” scheme is implemented to suppress contact bounce. There were no false positives.
### Identification and analysis of other electrical consumers
If the main meter is used in the system, then electricity consumers who do not have meters will be displayed as unknown in the statistics:
*Fig. Low-detailed energy statistics*
After identifying the obvious main consumers and playing enough with homegrown sketches, I realized that there are too many consumers left in the “Unknown” classification. It was decided to launch heavy artillery: a multi-channel counter WB-MAP12H. It allowed to determine the most “gluttonous” lines and to further differentiate energy consumption.
Most of the expenses were allocated to air conditioning (in summer), under-floor heating (in winter), breather (in winter), computer and multimedia. And yes, the kettle, which always works so noisily and puffs, turned out to be almost the lowest consumer.
The statistics of electricity consumption by category in BARY can be found in the tab “Events” — “Statistics”
*Fig. More detailed energy statistics.*
It is very convenient: when the consumption for any of the categories exceeds the average, the category is highlighted in red. Like “Air Conditioning” in the picture above. By the occupancy of this line, one can judge the magnitude of the excess as a percentage of the average.
You can also see what statistics are compiled for a particular category:
*Fig. Detailed statistics on devices*
### Avoiding data duplication
If you use a set of devices to analyze power consumption — a counter in the socket + a total counter per line — the readings will be doubled. BARY allows you to build a parent-child hierarchy. This is implemented as follows: for the devices themselves, we set the consumption category and a higher counter (see. Fig. “Configuring the device’s energy consumption parameters”).
A higher counter is needed if one counter reads the entire line and the other counts a specific socket. When viewing statistics, the readings of this socket will be subtracted from the readings of a higher counter, and the data will not be duplicated. If we take readings from the upstream meter and specific points, then part of the costs (the costs of those consumers who belong to the upstream meter line but do not hang on the sockets with a dedicated meter) will be displayed as unknown in the statistics. (see Fig. «Low-detailed energy statistics»)
Nesting itself is not limited in any way. For example, I use a scheme of up to 4 attachments.
And what`s next?
================
Let`s suppose we are finished with uncertainty, so how can we start saving now? Of course, each smart home will have its own specifics. But here are some general working recommendations.
### Scenarios “Leaving Home / Coming Home”
I highly recommend setting up a leaving home scenario! It seems to be obvious, but it works very well. In this scenario we include disabling everything that is possible. The scenario of returning home, respectively, returns everything to working mode.
*Fig. A list of devices disconnected when leaving home*
### “Good Night” Scenario
Have you ever wondered how much devices that are in standby mode consume? Just plugged in? I am. Yeah, I`m obsessed =)
For example, an air conditioner simply left in a wall socket consumes 1.4 Wh \* h. In a month it turns out 1.4 W \* h \* 24 h \* 30 days = 1 KW \* h, and at least six months a year it does not work.
Of course, the figure is not so big. But optimizing costs with a Smart Home system is worth nothing to us. But there can be not one, and not five of such “waiting” devices in a house. TVs, game consoles, computers and other devices. The more devices- the more expenses.
*Fig. A list of devices that are disabled in sleep mode*
### Temperature mode
We set the temperature regime of warm floors to be the minimum permissible. For example, in the bathroom the temperature is set at 26 ° C, this is a quite acceptable temperature and there is not much energy spent in this mode. If humidity is exceeded (someone takes a shower), we increase the temperature (during a shower, the floors usually have time to warm up by 2-3 degrees).
In the other rooms, we automatically turn off the warm floor using a motion sensor (why would we heat the floors if there is nobody in the room?).
If separate electric heaters are used, then we also connect their work to a temperature sensor (as with an air conditioner). If a breather of the “Tion” type is used, then in summer we try to run as little air as possible (it is hot and this is an extra work for the air conditioner), in winter it is the same with cold air (the breather itself warms it).
### Let there be light! But only in the case
If the lighting in bathrooms, dressing rooms, pantries and other similar rooms is still turned on and off manually, we attach it to the motion sensor. So you will never forget to turn off the lights! Well, also you won’t need to look for a switch in the dark kitchen next to the midnight refrigerator. In addition, it is not difficult at all to do this — there are a lot of Wi-Fi / Zigbee / 433 MHz switches on Aliexpress, including those without a zero line.
If you still use incandescent bulbs, halogen and other gluttonous light sources, then you should know:
On November 23, 2009, Federal Law No. 261-ФЗ “On Energy Saving” was issued, which stipulated that incandescent lamps with a capacity of 100 watts or more would be banned from production and sale from January 1, 2011, with a capacity of 75 watts or more being canceled from January 1 2013.
It's time to think about switching to more economical ones — LED and energy-saving.
With the same luminous flux of 1200Lm, an incandescent lamp consumes 100 watts, fluorescent / energy-saving — 25-30 watts, and LED — about 10 watts. Plus, the life of LED and energy-saving lamp is significantly longer than the life of an incandescent one.
Recently, we had an automation case that used incandescent lamps stylized as Edison lamps. Over 40 lamps of 60 watts each. Obtaining the statistics of energy consumption for one month, it was not surprising to find that more than a third of the electricity bill came from these lamps. All lamps were immediately replaced by similar, but already LED ones. They paid off very quickly.
Epilogue
========
For over 5 years of working on my smart home, many scenarios and automation processes have improved and undergone significant changes. Energy conservation has become a good habit. Now it is difficult to imagine that the warm floors are fried from morning to night, and the air conditioning is constantly buzzing. The weather in the house is comfortable, and payments for light please the eye and the wallet. BARY on guard of saving resources!
I hope this material was useful to you. If you have your own examples of optimizing electricity consumption, share in the comments what and how you managed to automate. And also join our group in VK and telegram! | https://habr.com/ru/post/515540/ | null | en | null |
# Доступное объяснение алгоритма коллапса волновой функции
Алгоритм коллапса волновой функции (Wavefunction Collapse Algorithm) учит компьютер импровизировать. На входе он получает архетипичные данные и создаёт процедурно генерируемые данные, похожие на исходные.
*([Источник](https://selfsame.itch.io/unitywfc))*
Чаще всего он используется для создания изображений, но может также строить [города](https://selfsame.itch.io/unitywfc), [скейтпарки](https://arcadia-clojure.itch.io/proc-skater-2016) и писать [ужасные стихи](https://github.com/mewo2/oisin).
*([Источник](https://selfsame.itch.io/unitywfc))*
Коллапс волновой функции — это очень независимо мыслящий алгоритм, не требующий практически никакой помощи или инструкций извне. Вам нужен только пример стиля, которого нужно достичь, а всё остальное он сделает сам. Несмотря на свою самодостаточность, он на удивление прост. Он не использует никаких нейронных сетей, случайных лесов или чего-то другого, похожего на машинное обучение. Если разобраться с идеей, он станет для вас очень понятным и интуитивным.
Большинство реализаций и объяснений коллапса волновой функции — это полная, оптимизированная по скорости версия алгоритма. Разумеется, все они важны и необходимы, но в них сложно разобраться с нуля. В этом посте я буду объяснять всё понятным я простым языком, сосредоточившись на версии Wavefunction с ограничениями, которую я назвал *Even Simpler Tiled Model*. Кроме того, я выложил [пример реализации ESTM на Github](https://github.com/robert/wavefunction-collapse). Код в нём неэффективный и медленный, но очень хорошо читаемый и подробно прокомментирован. Как только вы разберётесь в технологии, лежащей в основе ESTM, то станете ближе к пониманию более сложных версий алгоритма. Если хотите понять алгоритм коллапса волновой функции, то эта статья будет хорошим началом.
Давайте начнём с истории.
Свадьба
-------
Представьте, что вы планируете свою свадьбу. Кроме подбора украшений и музыки вам нужно создать план рассаживания гостей для обеда. Ваша семья любит поспорить и капризничать, поэтому это может оказаться сложным. Отец не может сидеть ближе чем в двух столах от матери. Двоюродной сестре становится одиноко, если она не сидит с другой двоюродной сестрой. А дядю Роя лучше не сажать рядом с экологически настроенными членами семьи вашего партнёра. Осталось всего 5 часов до прибытия еды, поэтому вы решаете атаковать эту упрямую задачу при помощи алгоритма коллапса волновой функции.
Вы начинаете с длинного списка правил и пустого плана рассаживания гостей.
Вы создаёте исходную *волновую функцию* плана. Она привязывает каждый стул к списку людей, которые на нём могут сидеть. Пока на любой стул может сесть любой человек. Волновая функция рассаживания гостей начинается с полной *суперпозиции* (понятие заимствовано из квантовой физики) каждой возможной схемы.
Кот Шрёдингера был одновременно мёртвым и живым, пока кто-нибудь не откроет ящик и не проверит; ваш план одновременно является каждой возможной схемой, пока вы не наведёте в нём порядок. Полная суперпозиция — полезная теоретическая конструкция, но она не поможет вашей бабушке разобраться, где ей нужно сидеть. Вам нужно привести волновую функцию расположения гостей к единственному определённому состоянию, которую потом можно превратить в обычные, неквантовые карточки с именами.
Начинаем мы это делать, выполняя *коллапс волновой функции* для одного стула. Выбираем стул, смотрим на список людей, которые могут на нём сидеть, и случайным образом назначаем его одному из них. При этом волновая функция стула становится коллапсированной.
Этот выбор имеет последствия, распространяющиеся на волновые функции остальных стульев. Если дядя Рой будет сидеть за столом 2, то кузен Фрэнк и Мишель Обама (друг семьи вашего партнёра) точно не будут рядом с ним. А если Мишель не сядет за стол 2, то Барака за ним тоже не будет. Мы обновляем волновую функцию плана расположения, вычёркивая людей из списков возможных кандидатов.
Как только колебания устоятся, мы повторяем этот процесс. Выбираем ещё один стул с несколькими возможными кандидатами и коллапсируем его волновую функцию, случайным образом выбирая одного из допустимых для него людей. Снова распространяем колебания, вызванные этим выбором, на весь остальной план, удаляя из волновой функции стула людей, если они больше не могут на нём сидеть.
Мы повторяем этот процесс или пока волновая функция не коллапсирует (то есть в ней не останется ровно 1 сидящий человек), или пока мы не достигнем *противоречия*. Противоречие — это стул, на котором не может сидеть никто, потому что всех их исключили из-за предыдущих выборов. Противоречие делает невозможность коллапс всей волновой функции.
Если вы достигли противоречия, то проще всего будет начать сначала. Отбросить всю предыдущую работу, найти новый пустой план и запустить алгоритм заново, выполнив коллапс волновой функции для другого случайного стула. Можно также реализовать систему возврата назад, позволяющую отменять отдельный выбор, а не отказываться сразу от всего («что если пересадить Шейлу на стул 54?»).
После нескольких фальстартов вы наконец достигнете полностью коллапсированного состояния, в котором каждый стул назначен ровно одному человеку и соблюдены все правила. Готово!
От свадьбы к битовым картам
---------------------------
Это не теоретический пример. Вы действительно можете реализовать вариант коллапса волновой функции, который будет создавать план рассаживания гостей для свадьбы. Однако в более традиционном Wavefunction Collapse мы обычно пытаемся не рассадить людей на свадьбе, а расставить пиксели на выходящем изображении. Тем не менее, процесс будет очень похожим. Мы обучаем алгоритм набору правил, которым должны удовлетворять выходные данные. Инициализируем волновую функцию. Выполняем коллапс одного элемента и распространяем последствия на остальную часть волновой функции. И продолжаем так делать, или пока волновая функция полностью не коллапсирует, или пока мы не достигнем противоречия.
Традиционный коллапс волновой функции отличается от свадебного коллапса тем, как мы обучаем алгоритм правилам, которые он должен соблюдать. В свадебной версии нам пришлось записывать правила самостоятельно. Но в традиционной версии мы просто даём алгоритму изображение-пример, и исходя из него алгоритм создаёт всё остальное. Он парсит пример, анализирует его паттерны и выясняет, как должны выстраиваться пиксели или *тайлы*.
Давайте начнём исследование реального коллапса волновой функции с рассмотрения простого особого случая, который [`ExUtumno`](https://twitter.com/exutumno) (создатель алгоритма) называет *простой тайловой моделью (Simple Tiled Model)*.
Simple Tiled Model
------------------
В модели Simple Tiled Model входящие и выходящие изображения строятся из небольшого количества заранее определённых тайлов, и каждый квадрат в выходящем изображении ограничивается только его четырьмя ближайшими соседями. Например, предположим, что мы генерируем случайные миры для двухмерной игры с видом сверху. У нас могут быть тайлы для суши, побережья и моря, а также набор правил вида «побережье может находиться рядом с морем», «суша может быть рядом с побережьем» и «море может быть рядом с другим морем».
*Simple Tiled Model* учитывает симметрию и поворот своих тайлов. Например, суша может находиться рядом с побережьем, но только в правильной ориентации.
Эта обработка симметрии обеспечивает более качественные выходные изображения, но усложняет код. Чтобы не усложнять, давайте рассмотрим ещё более простой вид коллапса волновой функции, который я назвал *Even Simpler Tiled Model*.
Even Simpler Tiled Model
------------------------
Even Simpler Tiled Model («ещё более простая тайловая модель») похожа на Simple Tiled Model, но её тайлы не имеют свойств симметрии. Каждый тайл — это один пиксель одного цвета, то есть мы никак не сможем перепутать их края.
Правила Even Simpler Tiled Model определяют, какие тайлы можно размещать рядом друг с другом и в какой ориентации. Каждое правило представляет собой кортеж из трёх элементов (3-tuple): двух тайлов и направления. Например, `(SEA, COAST, LEFT)` означает, что тайл `SEA` (море) может размещаться `СЛЕВА` от тайла `COAST` (побережье). Это правило должно сопровождаться другим правилом, описывающим ситуацию с точки зрения `COAST` — `(COAST, SEA, RIGHT)`.
Если вы хотите, чтобы тайлы `SEA` могли располагаться не только `СЛЕВА`, но и `СПРАВА` от тайлов `COAST`. то им нужны дополнительные правила: `(SEA, COAST, RIGHT)` и `(COAST, SEA, LEFT)`.
Как я сказал выше, нам не нужно создавать список всех этих правил самостоятельно. Коллапс волновой функции может создать набор правил для Even Simpler Tile Model парсингом изображения-примера и собиранием списка всех 3-tuple, которые в нём содержатся.
Исследовав показанный выше пример изображения, Even Simpler Tiled Model замечает, что тайлы моря могут быть только под или сбоку от тайлов побережья, или в любом месте рядом с другими тайлами моря. Также она замечает, что тайлы побережья могут располагаться рядом с сушей, морем или другими тайлами побережья, но только над тайлами моря и под тайлами суши. Она не пытается вывести никакие более сложные правила, например «тайлы моря должны быть рядом по крайней мере с одним тайлом моря» или «каждый остров должен содержать как минимум один тайл суши». Ни один из тайлов не может влиять на то, что какие-то типы тайлов могут или не могут располагаться в двух или более квадратах от них. Это похоже на модель плана свадьбы, в которой единственное правило: «X может сидеть рядом с Y».
При анализе входящего изображения нам также нужно записывать частоту, с которой встречается каждый из тайлов. Позже мы используем эти числа как веса при выборе волновой функции квадрата, коллапс которой нужно выполнить, а также при выборе тайла, назначаемого квадрату при его коллапсировании.
Узнав правила, которых должно придерживаться выходящее изображение, мы готовы к построению коллапсированию волновой функции выходящего изображения.
Коллапс
-------
Как и в примере со свадьбой, мы начинаем процесс коллапсированя с волновой функции, в которой каждый квадрат выходящего изображения находится в суперпозиции каждого типа тайла.
Начнём с выбора квадрата, волновую функцию которого будем коллапсировать. В примере со свадьбой этот выбор делался случайно. Однако, как заметил `ExUtumno`, люди обычно подходят к таким задачам иначе. Вместо этого они ищут квадраты с наименьшей *энтропией*. Энтропия — это мера неопределённости и беспорядка. В общем случае квадрат с высокой энтропией — это квадрат со множеством возможных тайлов, оставшихся в его волновой функции. Пока очень непонятно, к какому тайлу он в конечном итоге коллапсирует. Квадрат с низкой энтропией — это квадрат с малым количеством возможных тайлов в волновой функции. Набор тайлов, к одному из которых он в результате коллапсирует, уже очень ограничен.
Например, в модели Even Simpler Tile Model квадрат без информации об окружающих его квадратах ничем не ограничен и может стать любым тайлом. Следовательно, он имеет очень высокую энтропию. Но квадрат, вокруг которого уже коллапсировало несколько квадратов, может иметь на выбор всего 2 тайла.
Волновая функция центрального квадрата на рисунке выше не полностью коллапсировала, но мы уже знаем, что она не может быть тайлом суши. Тем не менее, она уже ограничена, а значит, имеет *энтропию* ниже, чем у правого верхнего квадрата, который всё ещё может быть сушей, морем или побережьем.
Именно на такие ограниченные тайлы с низкой энтропией обычно и обращают внимание люди, когда вручную решают подобные задачи. Даже если вы не пользуетесь коллапсом волновой функции для создания плана размещения гостей на свадьбе и будете составлять его самостоятельно, то всё равно сосредоточитесь на тех областях плана, в которых уже есть наибольшее количество ограничений. Вы не будете сажать Дуэйна за стол 1, а затем случайным образом перепрыгивать, чтобы посадить Кэти за стол 7 (который пока пуст). Вы сначала посадите Дуэйна, потом разберётесь, кто может сидеть рядом с ним, затем кто может сидеть рядом с этим человеком, и так далее. Я пока не видел обоснований этого, но моя интуиция говорит, что при использовании этой *эвристики минимальной энтропии* скорее всего будет получаться меньше *противоречий*, чем при случайном выборе квадратов для коллапсирования.
В качестве формулы энтропии в алгоритме коллапса волновой функции применяется *формула Шеннона*. В ней используются веса тайлов, которые мы спарсили из входящего изображения на предыдущем этапе:
```
# Sums are over the weights of each remaining
# allowed tile type for the square whose
# entropy we are calculating.
shannon_entropy_for_square =
log(sum(weight)) -
(sum(weight * log(weight)) / sum(weight))
```
Вычислив квадрат волновой функции с наименьшей энтропией, мы коллапсируем её волновую функцию. Мы делаем это, случайным образом выбирая один из тайлов, пока ещё доступных для квадрата, взвешенный на веса тайлов, которые мы спарсили из входящего изображения. Веса используются потому, что это обеспечивает более реалистичное изображение на выходе. Допустим, волновая функция квадрата сообщает, что он может быть сушей или побережьем. Мы не всегда должны выбирать один из вариантов с вероятностью 50%. Если во входящем изображении больше тайлов суши, чем побережья, то нам стоит отразить этот перевес и в выходном изображении. Реализуется это при помощи простых глобальных весов. Если в примере изображения есть `20` тайлов суши и `10` тайлов побережья, то квадрат коллапсирует в сушу с вероятностью `2/3`, а в побережье — с оставшейся вероятностью `1/3`.
Затем мы распространяем последствия выбора на остальную волновую функцию выходных данных («если тот тайл оказался морем, то этот не может быть сушей, то есть этот не может быть побережьем»). Когда все эти сотрясения улягутся, мы повторяем процесс, используя эвристику минимальной энтропии для выбора следующего коллапсирующего тайла. Повторяем этот цикл коллапсирования-распространения, или пока вся волновая функция выходного изображения полностью не коллапсирует и мы сможем вернуть результат, или пока мы не достигнем противоречения и вернём ошибку.
В итоге мы создали мир (или ошибку).
Куда двигаться дальше
---------------------
Разобравшись с моделью Even Simpler Tiled Model, вы готовы подниматься выше по лестнице мощности и сложности алгоритма. Начните с Simple Tiled Model, которую мы упоминали в начале этого поста, затем перейдите к полной Overlapping Model. В Overlapping Model тайлы или пиксели влияют друг на друга издалека. Если вы понимаете в таких вещах, то `ExUtumno` замечает, что Simple Tiled Model схожа с цепью Маркова порядка-1, а более сложные модели напоминают цепи большего порядка.
Wavefunction Collapse даже может учитывать дополнительные ограничения, например «этот тайл должен быть морем» или «этот пиксель должен быть красным» или «в выходных данных может быть только один монстр». Обо всё этом рассказывается [README основного проекта](https://github.com/mxgmn/WaveFunctionCollapse). Также можно изучить оптимизации скорости, внесённые в полную реализацию. Необязательно повторно вычислять энторпию каждого квадрата в каждой итерации, а распространение информации по волновой функции можно сделать значительно быстрее. Эти аспекты становятся важнее при увеличении размеров выходящих изображений.
Коллапс волновой функции — это красивый и мощный инструмент, который стоит освоить. Вспомните об этом, когда в следующий раз будете планировать свадьбу или генерировать процедурный мир. | https://habr.com/ru/post/461323/ | null | ru | null |
# Граф Скоринг де ля Фер или исследование на тему кредитного скоринга, в рамках расширения кругозора. Ч.2
[AntipovSN](https://habr.com/ru/users/antipovsn/) and [MihhaCF](https://habr.com/ru/users/mihhacf/)
*Часть вторая, в которой Атосу все норм, а вот Графу де ля Фер чего-то не хватает*
[**UPD Часть первая здесь**](https://habr.com/ru/post/464447/)
[**UPD Часть третья здесь**](https://habr.com/ru/post/465927/)
**Вступление от авторов:**
Добрый день! Сегодня мы продолжаем цикл статей, посвященный скорингу и использованию в оном теории графов. С первой статьей Вы можете ознакомиться [здесь](https://habr.com/ru/post/464447/).
Все шуточные аллегории, вставки и прочее призваны немного разгрузить повествование и не позволить ему свалиться в нудную лекцию. Всем, кому не зайдет наш юмор, заранее приносим извинения
**Цель данной статьи:** не более, чем за 30 минут, описать основные способы хранения данных о графах и описать правила и принципы построения нашей модели для скоринга заемщика.
**Термины и определения:**
* [Хеш-таблица](https://ru.wikipedia.org/wiki/%D0%A5%D0%B5%D1%88-%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D0%B0) — это структура данных, реализующая интерфейс ассоциативного массива, она позволяет хранить пары (ключ, значение) и выполнять три операции: операцию добавления новой пары, операцию поиска и операцию удаления пары по ключу. Поиск по хеш-таблице, в среднем, осуществляется за время О(1).
Аудиторы, нанятые ПАО «Король» для оценки кредитоспособности НПАО «Один за всех», столкнулись с некоторыми проблемами. С одной стороны, описать схему взаимодействия 10-15 компаний и провести первичную оценку взаимодействия между компаниями очень просто, достаточно иметь под рукой лист бумаги и ручку. Но, что делать, если у вас имеется информация о взаимодействии десятков или сотен тысяч компаний? *Например, если Вам нужно описать взаимодействия Арамиса со всеми его пассиями или Д’артаньяна со всеми, с кем он дрался?*
Как хранить данные об этих взаимодействиях?
Какие структуры данных и подходы использовать?
Аудиторам пришлось бы сажать за эту работу целый монашеский корпус писунов.
Мы так делать не будем и наделим наших аудиторов знаниями и технологиями будущего (*отправим к ним Прометея в виде Т-800, который даст им свет знаний*).
Ну, что ж, начнем отвечать на поставленные вопросы. Да будет свет!
Как мы уже писали и рисовали [здесь](https://habr.com/ru/post/464447/), граф – это отношение 2-х множеств – множества узлов и множества ребер. Как же лучше хранить граф?
Прежде чем ответить на вопрос как хранить граф, нужно решить, а что конкретно мы хотим хранить и в каком виде.
По теории графов узлами графа могут быть любые объекты с любым набором параметров (этот факт пригодится нам позже, для продвинутых/адаптивных моделей расчета скорингового бала).
Так что же нам нужно хранить?
Как минимум, идентификатор узла и идентификаторы его соседей (с кем связан). Наличие этих данных уже позволяет осуществлять поиск в ширину и глубину.
Нужно ли хранить данные о ребрах графа? Да, если мы имеем дело со взвешенным графом. В нашем случае, мы имеем дело со взвешенным графом и в [первой статье](https://habr.com/ru/post/464447/) мы нарисовали именно такой граф.
Достаточно ли этой информации? Нет.
Откуда взялись веса у ребер? В учебниках эта информация просто есть, кто-то ее собрал и обработал до нас. В нашем же позднем средневековье (именно тогда жили мушкетеры) никто не озаботился подсчетом весов ребер нашего графа. Мы должны сделать это сами. В этой и следующей статье мы не будем расписывать конкретную методику расчета веса ребра, это будет сделано в 4 статье. Сейчас нам важно определиться какую информацию о нашем графе мы будем хранить.
Итак, в нашем случае, есть три ключевых параметра, которые мы должны знать для корректного расчета скорингового балла:
* Внутреннюю оценку узла – складывается из показателей, характеризующих узел (оборот, задолженности, штрафы и пр). В нашем примере это будут:
+ Оценка — хороший или плохой узел по отношению к НПАО «Один за всех»;
+ Ранг узла – Король имеет наивысший ранг, Бонасье – наименьший;
+ Объем фондов, проще говоря, состоятельность.
* Оценку ребра. В нашем случае оценка связи будет для каждого узла – это значит, что связь Бонасье – Констанция может не равняться связи Констанция – Бонасье, т.к. они имеют разные возможности влияния друг на друга.
* Уровень узла – храниться не будет, но является важным показателем.
Не спрашивайте откуда взялись в модели все эти числа, Д’артаньян так видит. В реальной жизни эти показатели будут рассчитываться тоже не нами (торговый оборот, долги, штрафы и пр. мы берем из уже существующих источников, мы ж не в средневековье, вроде).
Из всего вышеперечисленного получается, что мы должны хранить помимо идентификаторов узлов, параметры каждого узла и веса ребер, которые мы получаем на основании агрегации параметров узлов.
Итого, хранению подлежит следующая информация:
* Название узла;
* Параметры узла;
* Соседи узла;
* Вес ребра для каждого соседа.
Отлично! Разобрались, что нам нужно хранить. Теперь — как хранить.
И опять небольшое отступление.
Как будет выглядеть наш процесс скоринга в упрощенном виде:
* Сбор данных об объекте;
* Формирование объекта, который будет описывать модель графа. Именно на этом объекте мы будем проводить все наши операции скоринга.
Исходя из этих двух этапов у нас есть три варианта:
* Храним данные об объекте скоринга на SQL / NoSQL сервере. Все операции, связанные с расчетами, алгоритмами и пр. проводим непосредственно на сервере;
* Храним данные об объекте скоринга на SQL / NoSQL сервере. На основании этих данных создаем отдельный объект (например, хеш-таблицу), с которой проводим все основные вычисления;
* Данные об объекте скоринга храним в оперативной памяти. На основании этих данных создаем отдельный объект (например, хеш-таблицу), с которой проводим все основные вычисления.
Основные требования к данному процессу:
* Скорость работы;
* Надежность;
* Верифицируемость.
Теперь давайте рассуждать. *Сядем, как наши мушкетеры за кружечкой чего они там пили, чая, например. Главное, чтобы нам не мешали всякие петухи с гвардейцами.*
Если нужно долговременное хранение, то можно выбрать таблицу, с соответствующими значимыми полями. В NoSQL или оперативной памяти лучше хранить данные в виде списка или справочника (хеш-таблица) объектов.
```
{ 'Id': 1, 'Title': 'НПАО Один за всех', 'Rang': 4, 'Type': 'НПАО', 'Profit': 10000 }
```
С вершинами более-менее понятно. Как же лучше представить дуги/ребра графа? Для этого нужно понимать основной принцип любых аналитических операций над графом – обращение к любой дуге/ребру должно происходить очень быстро, желательно, чтобы время обращения было равно O(1). Сразу в голову приходить массив или матрица – структура, в которой к любому элементу можно обратиться быстро по индексу.
[i,j] – элемент матрицы обозначает дугу графа, где i- идентификатор начальной вершины, j — идентификатор конечной вершины, обращение и выбор начальной вершины происходит непосредственно по идентификатору начальной вершины. Пересечение i и j хранит вес ребра.
В таком представлении есть несколько минусов:
* Часто структура бывает избыточна, особенно, если граф разреженный (малое количество ребер), много пустых значений, которые обозначают, что связи нет.
* Для нахождения всех соседей вершины нужно перебрать массив всех элементов i-той строки матрицы отношений.
* Матрицу с многими столбцами не сохранить в БД.
Следующий вариант хранения дуг/ребер – таблица, то есть набор столбцов и строк.
Например:
Такую структуру можно легко сохранить в реляционной БД и при выполнении SQL запросов выбирать нужные значения, но, когда речь идет об оперативной памяти, сложность поиска всех ребер вершины увеличивается и в общем случае занимает O(n) где n количество всех ребер графа.
Существует еще один очень хороший метод хранения графа для использования практически во всех системах, лишенный недостатков, описанных выше — это справочник ключ-значение или хеш-таблица. Получение всех ребер нужной вершины происходит с O(1) скоростью.
Существенный минус, что не все языки программирования поддерживают такую конструкцию.
Как же можно представить подобную структуру в разных системах?
В реляционной базе можно реализовать связь таблиц объектов и ребер (предыдущий пункт)
**NoSQL**
```
{ 'Id': 1, 'Title': 'НПАО Один за всех', 'Rang': 4, 'Type': 'НПАО', 'Profit': 10000, 'Relations': [{3,2}, {4,5}, … {n, -5}] }
```
При обращении к объекту по его ключу, сразу получаем набор его связей. Если у нас невзвешенный граф, вместо массива объектов можно передать массив идентификаторов соседей Relations: [3,4, … n]. В виде справочника ключ – значение, такой вариант похож на предыдущий. В справочнике ключ – значение можно хранить такой же объект, как в предыдущем примере, ключом, конечно, будет являться идентификатор вершины (может быть число, может быть строка и т.д., что позволяет конкретная системы разработки). Так же в справочнике можно хранить только массивы связей, а информацию о вершинах в другом справочнике.
```
Graf[1] = { 'Id': 1, 'Title': 'НПАО Один за всех', 'Rang': 4, 'Type': 'НПАО', 'Profit': 10000, 'Relations': [{3,2}, {4,5}, … {n, -5}] }
```
или
```
graf['one_for_all'] = 'Relations': [{3,2}, {4,5}, … {n, -5}]
```
Для нашего примера мы выбрали вариант хранения данных в оперативной памяти с созданием хеш-таблицы для скоринга данных. Промежуточные результаты будем записывать в файл на сервере.
Со структурами хранения худо – бедно определились, теперь пришло время разобраться, с чего начать построение нашей аналитической модели. Начнем с простого- определим взаимодействие с ближайшими соседями и с соседями соседей (друзья друзей).
Таким образом можно определить взаимодействие со всем связанными между собой вершинами. По нашим наблюдениям взаимодействие с соседями глубже 2 уровня представляет интерес только в особенных случаях и рассчитывается по другим методикам. Сложность этого расчета довольно велика 0(2^n).
Для расчета бала мы будем использовать немного измененный алгоритм поиска в глубину.
Доработка будет заключаться в следующем:
1. Нужно найти не конкретную вершину, а перебрать все вершины на глубину n, для нашей задачи n=2.
2. Мы не должны хранить лишнюю информацию и должны предполагать, что расчет может производиться для любого узла графа, поэтому уровень узла храниться в графе не будет.
3. Если в вершину ведут 2 и более путей, то оцениваются все пути, т.к. мы имеем дело с двунаправленными связями и необходимо максимально полно оценить взаимодействия узлов.
4. Нужно иметь возможность определять уровень вложенности любой вершины для конкретного расчета.
Ну, что ж, основные теоретические выкладки сделаны, пусть они и покажутся кому-то чем-то простым и банальным. Но для нас, гасконцев, это все важно и интересно, почти так же, как поступление в Королевские мушкетеры.
Переходим к практической реализации. Один за всех и все на одного!
Встретимся! Мы обязательно встретимся! Может быть через 10 лет или 20! Но встретимся!
Следующая статья близко! | https://habr.com/ru/post/464833/ | null | ru | null |
# Представляем MPS 2020.3
Несколько месяцев мы работали над тем, чтобы сделать MPS еще удобнее, и исправляли проблемы, о которых вы нам сообщали. Скачать новый MPS 2020.3 можно на [нашем сайте](https://www.jetbrains.com/ru-ru/mps/download/) или с помощью [приложения Toolbox](https://www.jetbrains.com/ru-ru/toolbox-app/).
Новый макрос генератора
-----------------------
Мы добавили новый макрос *$CALL-SITE$*. Он упрощает вставку узла, на который указывает макрос *SWITCH/CALL*, в указанное место в вызванном шаблоне. Раньше узел с прикрепленным макросом *SWITCH/CALL* обычно игнорировался. Теперь, если вызванный template/switch пытается использовать «call site node», то узел обрабатывается как обычный шаблон, и результат передается в вызванный template/switch как неявный аргумент, который можно вставить в желаемое место.
Вот как выглядит вызов шаблона reduce\_Comment, служащего «местом вызова» шаблона reduce\_MethodDeclaration:
Если мы заглянем в шаблон, увидим, что там есть call site node с оператором $CALL-SITE$ в теле метода:
Также теперь есть вызов переключателя reduce\_Expressions, параметризованного узлом шаблона (вызов метода трассировки) с помощью макроса свойства и макроса ссылки (который обеспечивает то, что вызов метода указывает на правильное объявление метода в другом месте). Внутри переключателя *$CALL-SITE$* заменяет вызов метода-заполнителя на тот, который является call site node:
В объявлениях шаблона и переключателя есть флаг, который специально переключается, чтобы указать, что должен использоваться call site node. Использовать макрос $CALL-SITE$ внутри шаблона/переключателя, который не указывает на необходимость получения $CALL-SITE$, будет ошибкой. Нет необходимости указывать явный аргумент в CALL/SWITCH —генератор MPS может определить, нужен ли вызываемому шаблону/переключателю call site, и вычисляет шаблон, включая макросы, CALL/SWITCH перед обработкой.
Эта функциональность полезна в таких сценариях, как приведение условных типов, например в выражениях `IF needCast (Type), ELSE`, или в преобразованиях, когда есть несколько источников выражения, которые могут служить входными данными, например `switch { case Double : Double.valueOf(expression); case Integer : Integer.valueOf(expression, 16); …}`. Поэтому нецелесообразно иметь специальный переключатель/шаблон для каждого случая.
Динамическая подсветка в редакторе
----------------------------------
В редакторе появилась [долгожданная](https://youtrack.jetbrains.com/issue/MPS-3071) динамическая подсветка. Эта функция очень похожа на действие *Highlight Usages* (Ctrl/Cmd+Shift+F7). Разница в том, что динамическая подсветка срабатывает автоматически при вводе кода или навигации по нему. Ссылки на узел, находящийся под курсором, подсвечиваются в редактируемом документе практически сразу. Вы по-прежнему можете использовать действие *Highlight Usages*, чтобы видеть использования выбранного узла, когда навигируетесь в другое место. При этом динамическая подсветка продолжит выделять использования узла под курсором.
Функция включается и выключается в настройках редактора MPS (опция *Highlight selected node*).
Улучшенный switch-оператор в BaseLanguage
-----------------------------------------
В дополнение к улучшениям в редакторе, концепт switch теперь поддерживает использование нескольких case для одного и того же оператора.
Полоса ошибки на панели Project
-------------------------------
На панели Project ошибки, предупреждения и сообщения отображаются по-новому. Полосы ошибок помогают упорядочить сообщения. Вы можете отключить их с помощью кнопки в настройках Logical View.
Изменения в обработке фасетов модулей
-------------------------------------
Вы больше не обязаны использовать какой-то определенный фасет модуля с любым модулем. Фасеты, связанные с модулем, записываются в файл дескриптора модуля, который теперь является основным источником информации. В предыдущих версиях мы уже сделали фасет *Tests* необязательным, теперь это касается и последнего фасета — *Java*. Обратите внимание, что снятие галочки с фасета *Java* в модуле Language исключит язык из механизма загрузки классов, и все будет работать по-другому. Мы внесли это изменение, чтобы улучшить поддержку других языков.
Улучшенная аннотация корня в VCS
--------------------------------
Старый алгоритм корневых аннотаций использовал результаты, полученные из текстового файла модели. Раньше он работал только для моделей с сохранением текста и не всегда корректно. Благодаря новому подходу аннотация строится путем сравнения моделей из разных версий.
Каждую ячейку в редакторе теперь можно аннотировать с помощью опции *Annotate cells*: 
В результате вы увидите последние изменения каждой ячейки во всплывающей подсказке:
Вы можете выбрать версию в столбце Annotation, и MPS подсветит все ячейки, в которые были внесены изменения:
Отслеживание перемещенных узлов в окне Diff
-------------------------------------------
Предыдущий алгоритм расчета различий между двумя моделями не мог обнаружить некоторые типы изменений. Перемещение узла рассматривалось как два независимых изменения: вставка и удаление. Теперь это отображается как одно действие. Кроме того, можно отследить изменения внутри перемещаемого фрагмента:
Вы можете выбрать, следует отслеживать перемещенные узлы в окне Diff или нет: 
Иногда порядок узлов одного уровня не имеет значения. Вы можете скрыть несущественные перестановки, используя новую опцию *Hide Unordered Moves*.
Обновленный начальный экран
---------------------------
Начальный экран MPS выглядит по-новому. Теперь там можно не только выбрать проект, но и настроить MPS в соответствии с вашими потребностями. На странице *Projects* теперь больше места — она вмещает больше проектов, которые легко искать через поле поиска. На странице *Customization* можно настроить основные параметры интерфейса, например тему и шрифт, параметры импорта и общего доступа.
Другие улучшения
================
Обновленное меню VCS
--------------------
Меню VCS теперь называется в соответствии с той системой контроля версий, которую вы используете. Если у вас в проекте используется только Git, меню VCS будет выглядеть так:
Еще мы улучшили его внешний вид и убрали из него все действия, кроме самых актуальных. Теперь легко получить доступ к ключевым функциям Git — они больше не спрятаны в подменю.
Кнопка Commit and Push
----------------------
Две самые популярные кнопки — Commit и Commit and Push… — теперь отображаются в окне Commit. Вы можете запушить изменения в удаленный репозиторий сразу после коммита, и больше не нужно прокручивать раскрывающийся список, чтобы добраться до кнопки Commit and Push.
Улучшенные ветки
----------------
Некоторые улучшения в этой версии касаются работы с ветками. Теперь MPS автоматически исправляет недопустимые символы в именах веток, и вы видите все действия, связанные с текущей веткой.
Удобное управление вкладками в редакторе
----------------------------------------
При работе над большим проектом удобно держать открытыми несколько вкладок. Теперь вы можете разделить главный экран редактора по горизонтали или по вертикали, просто перетащив вкладку в удобное место. Редактор подсветит, где она может быть закреплена. Закрепленные вкладки теперь отображаются в самом начале панели вкладок.
Кроме того, мы исправили [множество ошибок](https://youtrack.jetbrains.com/issues/MPS?q=%23Resolved%20%20project:%20MPS%20version:%20%7B2020.3%20EAP1%7D,%20%7B2020.3%20EAP%7D,%20%7B2020.3%20EAP2%7D,%20%7B2020.3%20EAP3%20(FF)%7D%20,%20%7B2020.3%20EAP4%20(Beta)%7D,%20%7B2020.3%20EAP5%7D%20,%20%7B2020.3%20RC%7D%20%20). Очень ждем ваших отзывов в комментариях и баг-репортов [в нашем трекере](https://youtrack.jetbrains.com/issues/MPS).
Хорошего дня и будьте здоровы!
*Ваша команда MPS
The Drive to Develop* | https://habr.com/ru/post/536854/ | null | ru | null |
# JavaScript в 3D: введение в Three.js
*Привет, Хабр! Представляю Вашему вниманию перевод [статьи](https://medium.com/javascript-in-plain-english/javascript-in-3d-an-introduction-to-three-js-780f1e4a2e6d) «JavaScript in 3D: an Introduction to Three.js» автора Брета Кемерона (Bret Cameron).*
Введение
--------
Three.js это мощный инструмент. Он помогает использовать 3D дизайн в браузере с приемлемой производительностью. По началу Three.js может быть сложным, особенно если вы никогда не погружались в мир 3D программирования ранее.
У меня есть базовый опыт работы с игровым движком Unity и C#, но все равно многие концепции оказались новыми для меня. Я пришел к выводу, что сейчас совсем мало ресурсов для начинающих разработчиков, поэтому я и решил написать эту статью. В ней мы рассмотрим основные элементы Three.js сцены от полигональных сеток и материалов до геометрии, загрузчиков и много другого.
В конце этой статьи, у вас будет твердое понимание базовых аспектов, необходимых для добавления дополнительного измерения в ваш будущий веб проект.
Three.js примеры от [Ben Houston](https://threejs.org/examples/#webgl_lights_physical), [Thomas Diewald](https://threejs.org/examples/#webgl_lines_colors) and [StrykerDoesAnimation](https://threejs.org/examples/#webgl_loader_collada_skinning).
### Векторы и контейнеры – основные строительные блоки
Зачастую выделяют два основных класса в Three.js – *Vector3* и *Box3*. Если вы новичок в 3D, то это может звучать немного абстрактно, но вы встретите их еще очень много раз.
### Vector3
Самый основной 3D класс, содержащий три числа: *x,y и z*. Числа представляют собой координаты точки в 3D пространстве или направление и длину. Например:
```
const vect = new THREE.Vector3(1, 1, 1);
```
Большая часть конструкторов в Three.js принимают объекты типа *Vector3* в качестве входных аргументов, например *Box3*
### Box3
Этот класс представляет кубойд (3д контейнер). Его главная задача – создать контейнер вокруг других объектов – и все, наименьший кубойд в который поместится 3D объект. Каждый *Box3* выравнивается про осям *x, y и z.*Пример, как создать контейнер, используя *Vector3*:
```
const vect = new THREE.Vector3(1, 1, 1);
const box = new THREE.Box3(vect);
```
Пример как создать контейнер вокруг уже имеющегося 3D объекта:
```
const box = new THREE.Box3();
box.setFromObject(object);
```
Можно создавать сетки и без этих глубоких знаний, но как только вы начнете придумывать или изменять свои модели, эти классы точно пригодятся. Сейчас мы уйдем от абстракций к более видимым вещам.
### Полигональная сетка
В Three.js основной визуальный элемент на сцене это *Mesh*. Это 3D объект, составленный из треугольных прямоугольников (полигональная сетка). Он строится при помощи двух обектов:
*Geometry* – определяет его форму, *Material* – определяет внешний вид.
Их определения могут показаться немного запутанно (например, класс *Geometry* может содержать информацию про цвет), но главное отличие именно такое.
### Geometry
Основываясь на задаче, которую вы хотите достигнуть, возможно вам захочется определить геометрию внутри Three.js или импортировать другую из файла.
Используя функции как *THREE.TorusKnotGeometry*, мы можем создать сложные объекты одной строчкой кода. Мы скоро доберемся до этого, но сначала рассмотрим более простые формы.
Самая простая 3D фигура, кубойд или контейнер, может быть задан параметрами *width*, *height* и *depth*.
```
const geometry = new THREE.BoxGeometry( 20, 20, 20 );
```
Для сферы минимально нужно значение параметров *radius*, *widthSegments* и *heightSegments*. Две последние переменные указывают сколько треугольников модель должна использовать, чтобы представить сферу: больше количество – более гладко будет выглядеть.
```
const geometry = new THREE.SphereGeometry( 20, 64, 64 );
```
Если мы хотим сделать острые или треугольные формы, то можно использовать конус. Его аргументы это сочетание аргументов двух предыдущих фигур. Ниже, мы прописываем *radius*, *widthSegments* и *radialSegments*.
```
const geometry = new THREE.ConeBufferGeometry( 5, 20, 32 );
```
Это лишь часть самых распространенных фигур. Three.js имеет внутри очень много фигур из коробки, которые можно посмотреть в документации. В этой статье, мы расмотрим более интересные формы, построенные на основе метода *TorusKnotGeometry*.
Почему эти фигуры выглядят именно так как они выглядят? Этот вопрос выходит за рамки этой статьи, но я призываю вас экспериментировать со значениями параметров, потому что вы можете получить очень интересные фигуры одной строчкой кода!
```
const geometry = new THREE.TorusKnotGeometry(10, 1.3, 500, 6, 6, 20);
```
### Материалы
Геометрия задает форму наших 3D объектов, но не их внешний вид. Чтобы это исправить, нам нужны материалы.
Three.js предлагает из коробки 10 материалов, каждый из них имеет свои плюсы и настраиваемые параметры. Мы рассмотрим лишь часть самых полезных.
#### MeshNormalMaterial
*Полезен при быстром старте и запуске*
Мы начнем с *MeshNormalMaterial*, многоцветный материал, который мы использовали в примерах выше. Он соответствует нормальным векторам в панели RGB, другими словами, используются цвета для определения позиции вектора в 3D пространстве.
```
const material = new THREE.MeshNormalMaterial();
```
Заметим, что если вы хотите поменять цвет материала, то можно использовать CSS фильтр и изменять насыщенность:
```
filter: hue-rotate(90deg) .
```
По моему опыту, этот материал более полезен для быстрого страта и запуска. Для большего контроля ваших объектов лучше использовать что нибудь другое.
#### MeshBasicMaterial
*Полезен при отображении только скелета*
Если вы хотите придать фигуре единый цвет, то можно использовать *MeshBasicMaterial*, только если не применяется освещение. Я нашел полезным применения того материала в отрисовке скелета модели. Для отрисовки только скелета нужно передать *{ wireframe: true }* как параметр.
```
const material = new THREE.MeshBasicMaterial({
wireframe: true,
color: 0xdaa520
});
```
Главный недостаток этого материала в том, что абсолютно пропадает информация о глубине материала. Каждый материал имеет опцию для отображения только скелета, но только один материал решает проблему отсутствие глубины — *MeshDepthMaterial*
#### MeshLambertMaterial
*Полезен при высокая производительность, но низкой точности*
Это первый материал, который учитывает освещенность, поэтому нужно добавить немного света на нашу сцену. В коде ниже, мы добавляем точечные источники света с желтым оттенком для создания более теплого эффекта.
```
const scene = new THREE.Scene();
const frontSpot = new THREE.SpotLight(0xeeeece);
frontSpot.position.set(1000, 1000, 1000);
scene.add(frontSpot);
const frontSpot2 = new THREE.SpotLight(0xddddce);
frontSpot2.position.set(-500, -500, -500);
scene.add(frontSpot2);
```
Теперь добавим материал для нашей фигуры. Так как наша фигура похожа на украшение, я предлагаю добавить более золотистый цвет. Другой параметр, *emissive*, это цвет объекта исходящий от самого объекта (без источника света). Часто это лучше работает как темный цвет – например как темные тени серого, как в примере ниже
```
const material = new THREE.MeshLambertMaterial({
color: 0xdaa520,
emissive: 0x111111,
});
```
Как вы можете увидеть в примере ниже, цвет более менее правильный, но то, как он взаимодействует со светом не добавляет реалистичности. Для исправления этого, нам нужно использовать *MeshPhongMaterial* или *MeshStandardMaterial.*
#### MeshPhongMaterial
*Полезен при средней производительности и средней точности*
Этот материал предлагает компромисс между производительностью и точностью отрисовки, поэтому этот материал – хороший вариант для приложения, которое должно быть производительным наряду с более точной отрисовкой чем при *MeshLambertMaterial.*
Сейчас мы можем изменять свойство *specular* которое влияет на яркость и цвет отражения поверхности. Если свойство emissive обычно темное, то *specular* лучше работает для светлых цветов. Ниже мы используем светлый серый.
```
const material = new THREE.MeshPhongMaterial({
color: 0xdaa520,
emissive: 0x000000,
specular: 0xbcbcbc,
});
```
Визуально, изображение сверху отражает свет более убедительно, но все еще не идеально. Белый свет слишком яркий и материал выглядит более ребристо, чем металлически (а мы стремимся именно к этому). Мы можем получить результат лучше, используя *MeshStandardMaterial.*
#### MeshStandartMaterial
*Полезен при высокой точности, но низкой производительности*
Это самый точный материал из всех, хотя его использование повлечет за собой издержки использования большей мощности. *MeshStandartMaterial* используется с дополнительными параметрами *metalness* и *roughness*, каждый из которых принимает значение между 0 и 1.
Параметр *metalness* влияет на то, как объект отражает, становясь ближе природе металла. Все потому что проводниковые материалы как металлы имеют другие отражающие свойства в отличии от диэлектриков таких как керамика.
*Roughness* добавляет дополнительный слой для кастомизации. Можно представить его как как противоположность глянцевости: 0 – очень глянцевый, 1 – очень матовый.
```
const material = new THREE.MeshStandardMaterial({
color: 0xfcc742,
emissive: 0x111111,
specular: 0xffffff,
metalness: 1,
roughness: 0.55,
});
```
Это самый реалистичный материал из всех представленных в Three.js, но и самый ресурсозатратный
Материалы, которые мы обсуждали внизу это те, которые я встречал чаще всего и посмотреть все варианты можно в доке.
### Загрузчики
Как мы уже обсудили выше, можно вручную определять геометрию и полигональные сетки. На практике люди чаще загружают свои геометрии из файлов. К счастью, Three.js имеет немного поддерживаемых загрузчиков, поддерживающих многие 3D форматы.
Основной *ObjectLoader* загружает JSON файл, используя *JSON Object/Scene format*. Большинство загрузчиков нужно импортировать вручную. Вы можете найти полный список поддерживаемых загрузчиков тут и импортировать их. Ниже небольшой список того что можно импортровать.
```
// GLTF
import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
// OBJ
import { OBJLoader } from 'three/examples/jsm/loaders/OBJLoader.js';
// STL
import { STLLoader } from 'three/examples/jsm/loaders/STLLoader.js';
// FBX
import { FBXLoader } from 'three/examples/jsm/loaders/FBXLoader.js';
// 3MF
import { 3MFLoader } from 'three/examples/jsm/loaders/3MFLoader.js';
```
Рекомендуемый формат для онлайн просмотра – GLTF, по причине того, что формат “направлен на доставку ассетов в рантайме, компактный для передачи и быстрый для загрузки”.
Кончено, может быть очень много причин предпочитать определенный тип файлов (например, если качество в приоритете или нужно точность для 3D печати). Лучшая же производительность онлайн будет, при импорте GLTF.
```
import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
import model from '../models/sample.gltf';
let loader = new GLTFLoader();
loader.load(model, function (geometry) {
// if the model is loaded successfully, add it to your scene here
}, undefined, function (err) {
console.error(err);
});
```
### Соединяем все вместе
Одна из причин почему Three.js может показаться запугивающим в том, что создать что то с нуля можно лишь парой строчек кода. В каждом примере выше, нам нужно было создать сцену и камеру. Чтобы упростить, я держал этот код за рамками рассмотрения, но сейчас мы посмотрим как это будет выглядеть все вместе.
То, как вы организуете свой код решаете только вы. В более простых примерах, таких как в этой статье, есть смысл писать весь код в одном месте. Но на практике, полезно разделять отдельные элементы для возможности расширения кодовой базы и ее управления.
Для простоты, мы рассмотрим элементы, которые отрисуются как один объект, поэтому весь код мы разместим в одном файле.
```
// Import dependencies
import * as THREE from 'three';
import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js';
// Создаем сцену
const scene = new THREE.Scene();
scene.background = new THREE.Color(0x282c34);
// Определяем камеру, устанавливаем ее на заполнения окна браузера
const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 10000);
camera.position.z = 5;
// Определеяем "рисовальщика" и устанавливаем на окно браузера
const renderer = new THREE.WebGLRenderer();
renderer.setSize(window.innerWidth, window.innerHeight);
// Берем элемент DOM и прикрепляем renderer.domElement к нему
document.getElementById('threejs').appendChild(renderer.domElement);
// Добавляем управление, устанавливаем как цель тот же DOM элемент
let controls = new OrbitControls(camera, document.getElementById('threejs'));
controls.target.set(0, 0, 0);
controls.rotateSpeed = 0.5;
controls.update();
// Определяем (или импортируем) геометрию объекта
const geometry = new THREE.TorusKnotGeometry(10, 1.3, 500, 6, 6, 20);
// Определяем материал объекта
const material = new THREE.MeshStandardMaterial({
color: 0xfcc742,
emissive: 0x111111,
specular: 0xffffff,
metalness: 1,
roughness: 0.55,
});
// Создаем полигональную сеть, масштабируем ее и добавляем на сцену
const mesh = new THREE.Mesh(geometry, material);
mesh.scale.x = 0.1;
mesh.scale.y = 0.1;
mesh.scale.z = 0.1;
scene.add(mesh);
// Добавляем освещение, устанавливаем его и добавляем на сцену
const frontSpot = new THREE.SpotLight(0xeeeece);
const frontSpot2 = new THREE.SpotLight(0xddddce);
frontSpot.position.set(1000, 1000, 1000);
frontSpot2.position.set(-500, -500, -500);
scene.add(frontSpot);
scene.add(frontSpot2);
// Создаем функцию анимации, которая позволит вам отрисовать Вашу сцену и определить любое движение
const animate = function () {
requestAnimationFrame(animate);
mesh.rotation.x += 0.005;
mesh.rotation.y += 0.005;
mesh.rotation.z += 0.005;
renderer.render(scene, camera);
};
// Зовем функцию анимации
animate();
```
### Нужно ли использовать фреймворк?
Наконец то, пришло время обсудить стоит ли использовать Three.js со своим любимым фреймворком? На текущий момент, есть хороший пакет *react-three-fiber* для React. Для пользователей React, есть очевидные преимущества пользования пакетом как этот – вы сохраняете структуру работы с компонентами, которая позволяет переиспользовать код.
Для новичков я советую начать с обычного *Vanila JS*, потому что большинство онлайн материалов, написанных про Three.js относятся к Three.js на Vanila JS. Основываясь на моем опыте изучения, это может быть запутано и трудно изучать через пакет – например, вам придется транслировать Three.js объекты и методы на компоненты и пропсы. (как только вы освоите Three.js можете использовать любой пакет).
### Как добавить Three.js в фреймворк
Three.js дает HTML объект (чаще всего называется он *renderer.domElement*) который может быть добавлен к любому HTML объекту в вашем приложении. Например, если у вас есть *div* с *id=”threejs”* вы можете просто включит следующий код в ваш Three.js код:
```
document.getElementById('threejs').appendChild(renderer.domElement);
```
Некоторые фреймворки имет предпочтительные пути обращения к узлам DOM дерева. Например, *ref* в React, *$ref* в Vue или *ngRef* в Angular и это выглядит как массивный плюс на фоне прямого обращения к элементам DOM. Как пример, давайте рассмотрим быструю реализацию для React.
### Стратегия для React
Если вы используете React, то существует один путь внедрения Three.js файлов в один из ваших компонентов. В файле *ThreeEntryPoint.js* мы напишем следующий код:
```
export default function ThreeEntryPoint(sceneRef) {
let renderer = new THREE.WebGLRenderer();
// ...
sceneRef.appendChild(renderer.domElement);
}
```
Мы экспортируем это как функцию, которая принимает один аргумент: ссылку на элемент в нашем компоненте. Теперь мы можем создать наш компонент
```
import React, { Component } from 'react';
import ThreeEntryPoint from './threejs/ThreeEntryPoint';
export default class ThreeContainer extends Component {
componentDidMount() {
ThreeEntryPoint(this.scene);
}
render() {
return (
<>
this.scene = element} />
);
}
}
```
Импортированная функция *ThreeEntryPoint* должна вызываться в методе *componentDidMount* и передавать новый *div* как аргумент, используя ссылки
В качестве примера такого подхода в действии, можно склонировать репозиторий и попробовать самостоятельно: <https://github.com/BretCameron/three-js-sample>.
Заключение
----------
Есть еще очень много, что я могу расскзать про Three.js, но я надеюсь что эта статья дала вам достатчно информации для того, чтобы начать использовать эту мощную технологию. Когда я только начал изучать Three.js я не мог найти ни одного ресурса как эта статья, поэтому я надеюсь я помог сделать эту технологию более доступной для начинающих. | https://habr.com/ru/post/477956/ | null | ru | null |
# Создание универсального веб-приложения сайта Habrahabr.ru при помощи Web App Template
Хабровчане, привет!
В [предыдущей статье](http://habrahabr.ru/company/microsoft/blog/245945/) мы с вами познакомились с шаблоном для создания универсальных веб-приложений – [Web Application Template](http://wat.codeplex.com/). Если кратко, то Web Application Template позволяет вам «превратить» сайт в приложение для Windows, Windows Phone или Android, добавив в него возможности интеграции с ОС и механизм распространения через магазин приложений.
Сегодня мы рассмотрим практический пример: как при помощи Web Application Template быстро и просто создать веб-приложение для Windows и Windows Phone на основе сайта habrahabr.ru.
Создание универсального веб-приложения для сайта Habrahabr.ru
-------------------------------------------------------------
Для начала создадим в Visual Studio новый WAT проект. Напомню, он находится по пути: **File> New > Project > Templates > JavaScript > Web App Template for Universal Apps**
Сразу перейдем к файлу **config.json** и поменяем **start\_url** на адрес **habrahabr.ru**.
В качестве стартового проекта укажем проект Windows. Запускаем приложение и, вот, что мы видим на экране:
Все вроде бы неплохо, но на экране, помимо текста статей, отображается много лишнего. Красным я выделила то, без чего, на мой взгляд, можно обойтись:
Для того, чтобы убрать лишние элементы со страницы, я прописала дополнительные css настройки стилей в файле i**njected-styles.css**. Например, чтобы убрать панель «Рубрика» и «Популярное за сутки», не потребовалось ничего, кроме следующего кода:
```
.sidebar_right{
display:none;
}
```
Теперь приложение выглядит лучше, не правда ли?!
Но на этом модификация не закончена. Я хочу упростить навигацию по сайту при помощи панели навигации. Для того, чтобы ее добавить, в **config.json** вставьте следующий код:
```
"wat_navBar": {
"enabled": true,
"maxRows": 2,
"makeSticky": false,
"buttons": [
{
"label": "Main",
"icon": "street",
"action": "http://habrahabr.ru/"
},
{
"label": "Hubs",
"icon": "list",
"action": "http://habrahabr.ru/hubs/"
},
{
"label": "Companies",
"icon": "people",
"action": "http://habrahabr.ru/companies/"
},
{
"label": "Users",
"icon": "contact",
"action": "http://habrahabr.ru/users/"
}
]
},
```
Мы создали панель навигации с четырьмя кнопками, которые будут располагаться в один ряд.
Обратите внимание, что вы можете настроить navbar так, чтобы он отображался постоянно (**«makeSticky»: true**). Теперь поменяем цвет добавленной панели, переопределив ее стиль в файле **wrapper-styles.css**:
```
.win-navbar{
background-color: rgb(135,158,168);
}
```
Также, для удобства, вынесем ссылки на «пользовательское соглашение», «правила» и «помощь» на боковую панель, в раздел настроек. Добавим в **config.json** следующий блок кода:
```
"wat_settings": {
"enabled": true,
"privacyUrl": "http://habrahabr.ru/info/agreement/",
"items": [
{
"title": "Help",
"page": "http://habrahabr.ru/info/help/"
},
{
"title": "Rules",
"page": "http://habrahabr.ru/info/help/rules/"
}
]
}
```
Теперь на панели настроек появились прописанные выше ссылки:
### Оффлайн режим приложения
Очень важно, чтобы у пользователя была возможность работать с приложением в случае, если интернет соединение отсутствует. Шаблон Web Application Template поддерживает работу с оффлайн режимом приложения.
Есть несколько вариантов обработки события перехода приложения в оффлайн режим:
1. Отобразить страницу-заглушку с сообщением об ошибке в связи с отсутствием интернета и предупреждением о невозможности дальнейшей работы приложения.
2. Заранее закэшировать отдельные страницы (режим **SuperCache**), вывести сообщение об отсутствии интернет соединения. Таким образом приложение продолжит свою работу в режиме ограниченной функциональности.
Для того, чтобы добавить поддержку оффлайн режима, вставьте в файл **config.json** блок **wat\_offline**.
```
"wat_offline": {
"enabled": true,
"message": "There is no internet connection",
"superCache": {
"enabled": false,
"baseDomainURL": "http://habrahabr.ru/",
"addIndexedDBSupport": true,
"imagesGuardBand": true,
"preCacheURLs": [ ],
"ignoreURLs": [ ]
}
}
```
Для включения поддержки оффлайн режима, присвойте свойству **enabled** значение **true**.
Для настройки страницы – заглушки, которую пользователь увидит на экране в случае потери соединения, используйте файл **offline.html**, расположенный по адресу **template > offline.html**. Если корневой адрес не определен, то укажите в message сообщение-заглушку, которое вы хотите вывести на экране в случае потери соединения.
Если вы хотите, чтобы работа с вашим приложением сохранялась и при отсутствии соединения, включите режим SuperCache (внутри настройки **SuperCache** присвойте свойству **enabled** значение **true**).
Укажите адреса тех страниц, которые вы хотите закэшировать заранее в настройке **preCacheURLs**, а в случае, если вы не хотите, чтобы кэш страницы создавался – пропишите необходимые адреса в ignoreURLs.
Web Application Template поддерживает работу с базами данных IndexedDB (свойство **addIndexedDBSupport**), а также встроенные (inline) изображения (свойство **imagesGuardBand**).
С основными необходимыми настройками для приложения Windows мы закончили, теперь перейдем к созданию приложения для Windows Phone.
### Создаем приложение для Windows Phone
Теперь пришло время для Windows Phone версии приложения. Поскольку у ресурса Habrahabr.ru есть специальная мобильная версия сайта, то создать веб-приложение для мобильного будет еще проще, чем Windows версию. Скопируем папку config из shared-проекта отдельно в Windows и в Windows Phone проект. Откроем файл config.json в Windows Phone проекте, удалим все лишнее и изменим start\_url на сайт мобильной версии хабра: [m.habrahabr.ru](http://m.habrahabr.ru/).
Сразу после запуска, приложение выглядит неплохо, но, давайте, модифицируем его.
В Windows приложении мы вынесли основные ссылки на панель навигации и на панель настроек.
Для удобства, добавим панель приложения и поместим на нее некоторые ссылки, например, на профиль, хабы и правила сайта.
Обратите внимание, что, если вы делаете приложение для стороннего ресурса, вам необходимо дать ссылку на пользовательское соглашение (privacy policy).
Прежде чем добавить панель приложения, добавьте следующую настройку:
```
"wat_cortana": {
"enabled": true,
"appBar": true,
}
```
Далее добавляем блок **wat\_appBar** и указываем необходимые кнопки.
```
"wat_appBar": {
"enabled": true,
"makeSticky": false,
"buttons": [
{
"label": "Main",
"icon": "street",
"action": "http://m.habrahabr.ru/"
},
{
"label": "Hubs",
"icon": "list",
"action": "http://m.habrahabr.ru/hubs/"
},
{
"label": "Companies",
"icon": "people",
"action": "http://m.habrahabr.ru/companies/"
},
{
"label": "Privacy Policy",
"icon": "people",
"action": http://m.habrahabr.ru/info/agreement/"
}
]
}
```
Вот, что получилось:
Обратите внимание на ссылку “Сhange Config Host Address”, которая появляется при добавлении панели приложения в Windows Phone версию, а также является стандартной для панели настроек в Windows приложении. Вы можете менять config файл вашего приложения удаленно. О том, как это сделать, смотрите в [MVA курсе «Создание универсальных веб-приложений при помощи Web App Template»](http://www.microsoftvirtualacademy.com/training-courses/creating-a-universal-web-based-applications-with-web-app-template-rus) или в статье [Создание универсальных веб-приложений при помощи Web App Template](http://habrahabr.ru/company/microsoft/blog/245945/).
Наше универсальное приложение почти готово, осталось поменять иконки в приложении.
### Меняем иконки в приложении
Со стандартными иконками приложение выглядит очень неэстетичным. Давайте посмотрим, как поменять иконки (бейджи, тайлы, картинку стартового экрана).
Откройте файл **package.appxmanifest** (он свой для каждого Windows и Windows Phone проекта, необходимо добавлять изображения отдельно для каждого проекта). Перейдите во вкладку **Visual Assets** и прикрепите необходимые изображения. Например, если вы хотите поменять иконку, которая расположена слева в окне приложения, то меняем картинку **Square 30x30 Logo**, для изменения картинки toolbar’a – **Square 150x150 Logo**, а для картинки экрана загрузки меняем изображение **Splash Screen**.
Обратите внимание на возможность добавления живых плиток. Для того, чтобы добавить их, загрузите соответствующие картинки в манифест приложения (вкладка **Visual Assets**), затем перейдите во вкладку **Application** и в разделе **Tile Update** укажите частоту обновления плитки и ссылку на RSS поток, с которого будет подгружаться информация для обновления плитки.
Также в файл config.json необходимо добавить следующий код:
```
"wat_livetile": {
"enabled": true,
"periodicUpdate": 1,
"enableQueue": true,
"tilePollFeed": "http://habrahabr.ru/rss/hubs/"
}
```
Теперь на плитке приложения будет отображаться информация о новых постах.
На этом основная работа с приложением закончена. Можно заполнять манифест и готовить приложение к публикации.
### В заключение про будущее
В Windows 10 мы [анонсировали](http://blogs.windows.com/buildingapps/2015/03/02/a-first-look-at-the-windows-10-universal-app-platform/) идею «Web apps» как часть платформы. Подробности о том, как это работает можно посмотреть [в руководстве для разработчиков](https://channel9.msdn.com/Series/Developers-Guide-to-Windows-10-Preview) (см. серию "[Evolving the Web Platform](https://channel9.msdn.com/Series/Developers-Guide-to-Windows-10-Preview/14), начиная с 16 минуты).
Манифест WAT, сделанный на базе стандарта Manifest for Web Apps (W3C) хранится на вашем сайте, в настройках приложения вы указываете политики доступа к WinRT API. Готовое приложение можно будет разместить в магазине приложений.
Вы можете начать создавать веб-приложения сегодня с помощью WAT, публикуя приложения для Windows 8.1, Windows Phone 8.1 или Android, и переключиться на модель Windows 10 Web Apps, как только новая ОС выйдет в релиз.
#### Дополнительные ссылки
[Создание универсальных веб-приложений при помощи Web App Template](http://habrahabr.ru/company/microsoft/blog/245945/)
[MVA курс по созданию универсальных веб-приложений при помощи Web App Template](http://www.microsoftvirtualacademy.com/training-courses/creating-a-universal-web-based-applications-with-web-app-template-rus)
[Скачать Web App Template](http://wat.codeplex.com/)
[Документация по Web App Template](http://wat-docs.azurewebsites.net/Tools)
[Загрузить бесплатную или пробную Visual Studio](http://l.techdays.ru/go/getvs)
[Попробовать Microsoft Azure](http://l.techdays.ru/go/azuretrial)
[Изучить курсы Microsoft Virtual Academy](http://l.techdays.ru/go/mva) | https://habr.com/ru/post/254507/ | null | ru | null |
# API Тиньков.Инвестиции. Первые шаги
Практически с первых дней я стал клиентом Тиньков.Инвестиции.
И с этого же момента меня терзают смутные сомнения — отражает ли личный кабинет объективную реальность?
Дело в том, что я покупаю ценные бумаги, номинированные в долларах, но в ЛК цены всех активов отображаются в долларах, а итоговая стоимость портфеля в рублях.
И мне непонятно, это доллар вырос или я такой результативный инвестор?
А как же комиссии, налоги и прочие дивиденды?
Вот бы взять все мои сделки и расписать по ФИФО, как в складском учете… А сверху положить полученные дивиденды, а потом вычесть налоги.
Вот тогда я и увижу понятный мне результат.
Оказалось, у Тинькова есть API, которое позволяет писать торговых роботов (мне это совсем не интересно), а также загружать данные по своему портфелю и операциям.
У этого API есть официальное описание, но мне не все было понятно, пришлось разбираться.
Результаты этих разборок представляю вашему вниманию.
Полезные ссылки:
[Описание API](https://tinkoffcreditsystems.github.io/invest-openapi/auth/)
[Еще описание](https://github.com/reflash/tinkoff-python-api/blob/master/README.md#documentation-for-api-endpoints)
Получение токена и установка библиотеки
---------------------------------------
Перед началом работы нужно установить библиотеку и получить токен.
Установка библиотеки:
```
pip install -i https://test.pypi.org/simple/ --extra-index-url=https://pypi.org/simple/ tinkoff-invest-openapi-client
```
Цитирую официальную инструкцию по получению токена:
1. Зайдите в свой аккаунт на tinkoff.ru
2. Перейдите в раздел инвестиций
3. Перейдите в настройки
4. Функция «Подтверждение сделок кодом» должна быть отключена
5. Выпустите токен OpenApi для биржи и Sandbox. Возможно система попросит вас авторизоваться еще раз, не беспокойтесь, это необходимо для подключения робота к торговой платформе.
6. Скопируйте токен и сохраните, токен отображается только один раз, просмотреть его позже не получится, тем не менее вы можете выпускать неограниченное количество токенов.
На момент написания статью токен выдавался на странице [www.tinkoff.ru/invest/settings](https://www.tinkoff.ru/invest/settings/), кнопка в нижней части страницы.
С токеном для песочницы у меня возникали ошибки, поэтому я начал экспериментировать с боевой версией. Чего и вам желаю (Осторожно: не купите-продайте случайно что-то лишнее).
Авторизация
-----------
```
from openapi_client import openapi
token = 'тут нужно вставить ваш токен'
client = openapi.api_client(token)
```
Эти две строки делают все, что нам нужно.
Дальше работаем с переменной client.
Что у нас в портфеле
--------------------
Получим содержимое ~~нашего~~ вашего портфеля:
```
pf = client.portfolio.portfolio_get()
```
Посмотрим основные данные первого элемента:
```
print('value:', pf.payload.positions[0].average_position_price.value)
print('currency:', pf.payload.positions[0].average_position_price.currency)
print('balance:', pf.payload.positions[0].balance)
print('figi:', pf.payload.positions[0].figi)
print('ticker:', pf.payload.positions[0].ticker)
print('name:', pf.payload.positions[0].name)
```
В моем случае это:
```
value: 45.98
currency: USD
balance: 21.0
figi: BBG000BWPXQ8
ticker: BTI
name: British American Tobacco
```
value — Цена бумаги
balance — Кличество бумаг в портфеле, value и currency — их денежное выражение.
figi — [Financial Instrument Global Identifier](https://ru.qwe.wiki/wiki/Financial_Instrument_Global_Identifier) (Финансовый Глобальный Идентификатор инструмента)
ticker — [Тикер](https://ru.wikipedia.org/wiki/%D0%A2%D0%B8%D0%BA%D0%B5%D1%80) актива.
По этим данным мы можем узнать человекочитаемое название актива.
Для данного запроса нам это не нужно (см. поле name), но в других случаях пригодится.
Получаем название бумаги по FIGI и тикету
-----------------------------------------
```
# Получение инструмента по FIGI
instr = client.market.market_search_by_figi_get('BBG000BWPXQ8')
instr
```
Получаем:
```
{'payload': {'currency': 'USD',
'figi': 'BBG000BWPXQ8',
'isin': 'US1104481072',
'lot': 1,
'min_price_increment': 0.01,
'name': 'British American Tobacco',
'ticker': 'BTI',
'type': 'Stock'},
'status': 'Ok',
'tracking_id': 'a1979917d2141916'}
```
Эта API-функция у меня работает как надо. Видим, что 'BBG000BWPXQ8' -> 'British American Tobacco'.
А вот поиск названия актива по тикеру у меня не работает :(((
```
instr = client.market.market_search_by_ticker_get('BTI' )
print(instr)
```
Разработчики предложили обновить библиотеку, но даже после этого не взлетело.
Качаем справочник ценных бумаг
------------------------------
Впрочем, я решил этот вопрос кардинально. Скачал у Тинькова полный справочник торгуемых активов:
```
# Получение списка облигаций
bonds = client.market.market_bonds_get()
# Получение списка ETF
etfs = client.market.market_etfs_get()
# Получение списка акций
stocks = client.market.market_stocks_get()
instr_list = bonds.payload.instruments + etfs.payload.instruments + stocks.payload.instruments
instr_list[:3]
```
получил
```
[{'currency': 'RUB',
'figi': 'BBG00844BD08',
'isin': 'RU000A0JU898',
'lot': 1,
'min_price_increment': 0.1,
'name': 'МКБ выпуск 9',
'ticker': 'RU000A0JU898'}, {'currency': 'RUB',
'figi': 'BBG00R05JT04',
'isin': 'RU000A1013Y3',
'lot': 1,
'min_price_increment': 0.1,
'name': 'Черкизово выпуск\xa02',
'ticker': 'RU000A1013Y3'}, {'currency': 'RUB',
'figi': 'BBG00PNLY692',
'isin': 'RU000A100DC4',
'lot': 1,
'min_price_increment': 0.1,
'name': 'МСБ-Лизинг 002P выпуск 2',
'ticker': 'RU000A100DC4'}]
```
Как видим, figi и name там есть. Для моих целей — более чем достаточно.
Получаем список операций
------------------------
А вот самое интересное — получить список моих операций. В операции (в моем случае) попадают следующие действия:
* PayIn — Пополнение брокерского счета
* PayOut — Вывод денег
* BuyCard — Покупка с карты
* Sell — Продажа
* BrokerCommission — Комиссия брокера
* Dividend — Выплата дивидендов
* Tax — Налоги
* TaxDividend- Налоги c дивидендов
* ServiceCommission — Комиссия за обслуживание
Код для выгрузки портфеля:
```
from datetime import datetime
from pytz import timezone
# Качаем все операции с 30 сентября 2016 (я один из первых клиентов Тиньков Инвестиции)
d1 = datetime(2016, 9, 30, 0, 0, 0, tzinfo=timezone('Europe/Moscow')) # timezone нужно указывать. Иначе - ошибка
d2 = datetime.now(tz=timezone('Europe/Moscow')) # По настоящее время
ops = client.operations.operations_get(_from=d1.isoformat(), to=d2.isoformat())
```
Посмотрим, что получилось. В моем случае, представляет интерес этот элемент
```
ops.payload.operations[217]
```
Вот что он собой являет
```
{'commission': {'currency': 'USD', 'value': -0.42},
'currency': 'USD',
'date': datetime.datetime(2018, 11, 7, 10, 55, 53, 648913, tzinfo=tzoffset(None, 10800)),
'figi': 'BBG000PSKYX7',
'id': '42281525510',
'instrument_type': 'Stock',
'is_margin_call': False,
'operation_type': 'BuyCard',
'payment': -141.05,
'price': 141.05,
'quantity': 4,
'status': 'Done',
'trades': [{'date': datetime.datetime(2018, 11, 7, 10, 55, 53, 648913, tzinfo=tzoffset(None, 10800)),
'price': 141.05,
'quantity': 1,
'trade_id': '42636800'}]}
```
Нас интересуют поля:
* date — дата сделки
* figi — код актива
* operation\_type — тип операции
* payment — сумма операции. У налогов или комиссий указана именно она. price при этом None
* price — цена одной бумаги
* quantity — плановое количество бумаг
* trades — реальные биржевые сделки
Сразу возник вопрос — зачем нам какие-то trades, если есть price и quantity?
Все не так просто (план и факт)
-------------------------------
Как я понял, в quantity указано то количество бумаг, которые я хотел купить. А то, что фактически куплено, лежит в trades[i].quantity.
Т.е. если хотите обратится к фактическим сделкам, нужно перебрать то, что лежит в trades.
В ряде случаев, там None — например, для налогов или вводов/выводов средств.
Чтобы получить настоящие цифры, нужно смотреть и в сделки, и в биржевые операции:
```
for op in ops.payload.operations: # Перебираем операции
print(op.figi) # figi всегда берем из операции
print(op.operation_type) # и тип операции тоже
if op.trades == None: # Если биржевых сделок нет
print('price:', op.price) # Берем из операции цену бумаги
print('payment:', op.payment) # Сумму платежа
print('quantity:', op.quantity) # И количество бумаг
else:
for t in op.trades: # А если есть сделки - то перебираем их
print('price:', t.price) # И берем данные из них
print('quantity:', t.quantity)
print('--------------')
``` | https://habr.com/ru/post/496722/ | null | ru | null |
# SITH — техника CSS3 для плавной смены изображения
Доброго времени суток, Хабр!
Хотел бы рассказать Вам, каким образом я добился плавной смены цветов иконок при наведении на них курсора. Подобная проблема часто встречается на Facebook. Если иконка представляет собой синий силуэт на белом фоне, то при наведении курсора оба цвета меняются местами, причём происходит это мгновенно и выглядит немного резко. Мои эстетические чувства были задеты, и я разработал своё решение.
Не встретив на просторах Интернета чего-либо подобного, я взял на себя ответственность назвать этот метод SITH (Soft Image Transition on :Hover) — плавный переход изображения при наведении.
Под хабракатом Вы найдёте полное описание техники, весь код, несколько скриншотов и ссылку на демонстрационную версию.
Никто в общем-то не запрещает использовать разные значения прозрачности.
Но такой подход не позволит нам плавно сменить цвета в двух изображениях ниже
Мой метод основывается на том, что одно изображение находится над другим, и они плавно меняют свою прозрачность на противоположные значения. Если в данный момент не совершается переход, добавленный при помощи свойства **transition** из CSS3, то одно из изображений всегда видно пользователю.
HTML код:
```
```
CSS:
`.trash, .trash b {
display: block;
width: 24px;
height: 21px;
background: url(/demo/img/trash-sprite.png) no-repeat 0px -21px;
cursor: pointer;
-webkit-transition: .5s opacity;
-moz-transition: .5s opacity;
-ms-transition: .5s opacity;
-o-transition: .5s opacity;
transition: .5s opacity;
}
.trash {
position: relative;
background-position: 0px 0px;
}
.trash b {
position: absolute;
top: 0;
left: 0;
opacity: 0;
}
.trash:hover b {
opacity: 1;
}`
На следующей картинке представлен сам процесс.
Рабочий пример можно испробовать [здесь](http://bobrovnikov.me/demo/SITH-soft-image-transition-on-hover) | https://habr.com/ru/post/131299/ | null | ru | null |
# Телеграм бот на Python, для напоминаний о реквестах на BitBucket
Бот - для работы с репозиторием проекта в BitBucket.
Приветствую любителей ботов :-) Позвольте представить вашему вниманию бота для работы с репозиторием проекта в BitBucket.
Краткое описание моих скромных трудов.
Схема:
Пример сообщений в телеграм:
Сразу оговорюсь, я являюсь автоматизатором на Java. Начинал изучение с Python, поэтому и бота написал на нем, так как моя работа происходит на Java, мне захотелось вспомнить Python), поддерживать и углублять свои знания этого языка.
И вот мне пришла в голову идея создания бота. Который к слову на проекте используется в нашем командном телеграмм чате, состоящим из 9 человек. Я обдумал основные задачи для которых он был бы необходим, их три (по результатм опроса, позже, выяснилось этого достаточно, но можно расширять функционал по своему усмотрению и необходимости):
1. Информировать о новых пулл-реквестах
2. Напоминать о текущих, что бы их проверили и поставили апрув (подтверждение на мерж)
3. Информировать о комментах в реквесте, если их более 1
Задачи исходили в первую очередь из потребностей проекта. У нас бывало по долгу не проверялись реквесты. Их либо забывали проверять, либо не знали что реквест создан (у нас есть информирование по реквестам через корпоративную почту, но там бывают задержки, да и не всегда она читается).
Я понимаю, бота можно расширить до того, что он будет информировать о любых изменениях реквеста (аппрув, изменение названия, событие мержа реквеста), но тогда наш чат превратиться в чат бесконечного спама от бота, будет неудобно переписываться по рабочим вопросам между собой, поэтому я ограничился задачами, описанными, выше. Этого как оказалось вполне хватает, реквесты стали более быстро проверяться, комментироваться и отслеживаться, что не может не радовать).
Да бот оказался весьма кстати и как мне кажется полезен.
### Технологии и библиотеки
Прежде чем приступить к реализации бота, я разумееется поискал есть ли подобные боты, они были, но мне удалось найти только на GO и на Java примеры реализаций. Был, насколько я припоминаю, и на Python, но мне не подходила его реализация. Вообщем сделаю свой, решил я.
Я хотел сделать его максимально понятным и удобным в использовании. Разумеется так как он работает с конфидециальным корпоративным ресурсом я не могу деплоить его в облаках или на сторонних серверах, он работает у меня локально, меня и всех это устраивает. Будьте осторожны, если захотите использовать этого бота, с вашими конфидециальными данными (конечно если таковые есть), используйте бота в защищенных корпоративных сетях либо локально.
Я выбрал популярную библиотеку **Aiogram** для работы с телеграмм. Примеров ее использования достаточно много можно найти в совбодном доступе, роликов на ютубе достаточно.
Работу с API BitBucket была использована библиотека **Atlassian.**
Пример команды, можно подробнее посмотреть на GitHub:
```
from aiogram import Bot, Dispatcher, executor, types
from aiogram.types import ParseMode, Message
from aiogram.utils.markdown import text, bold, code
@dp.message_handler(commands=['start', 'help'])
async def start_bot(message: types.Message):
"""
Стартовая команда, для приветствия и инфо о боте
"""
try:
msg = text(code("Привет, это бот BitBucket\n") +
code("Для проекта: ") + bold(project.upper() + "\n") +
code("Репозитория: ") + bold(repository + "\n") +
code("Нажмите, просмотреть: ") + bold("/requests") + "\n" +
code("Посмотреть курсы валют: ") + bold("/currency"))
await bot.send_message(message.from_user.id, msg, parse_mode=ParseMode.MARKDOWN, reply_markup=kb_client)
except:
await message.reply("ВАЖНО: Вам нужно добавиться к боту, все уведомления идут в ЛС!!!")
@dp.message_handler(commands=['requests'])
async def send_open_pull_requests(message: Message):
"""
Команда для вывода Pull-requests в личку пользователю
:param message: класс Message от которого можно использовать
разные методы отправки сообщений
"""
size = bitBacketUtils.get_size_pull_requests()
try:
msg = text("🔥 У вас есть - " + bold(str(size)) + " Pull requests в статусе OPEN:\n")
await bot.send_message(message.from_user.id, msg, parse_mode=ParseMode.MARKDOWN)
except:
await message.reply("❗ Возникла ошибка, повторите команду! Или добавьтесь к боту!")
try:
if size == 0:
msg = text("Pull requests в статусе OPEN нет")
await bot.send_message(message.from_user.id, msg, parse_mode=ParseMode.MARKDOWN)
else:
for request in bitBacketUtils.get_open_pull_requests():
mess = text("🔹 Имя автора: " + bold(request["Имя автора"]) + "\n"
"🔹 Имя ветки: " + request["Commit branch"].replace("_", " ") + "\n"
"Состояние: " + code(request["Состояние"]) + "\n"
"Роль: " + code(request["Роль"]) + "\n"
"Статус проверки: " + code(request["Статус проверки"]) + "\n"
"👉 Кол-во проверок: " + bold(str(request["Кол-во проверок"])) + "\n"
"👉 Кол-во комментариев: " + bold(str(request["Кол-во комментариев"])) + "\n"
"🙏 Проверьте меня): ", request["Проверьте меня)"])
await bot.send_message(message.from_user.id, mess, parse_mode=ParseMode.MARKDOWN)
except:
await message.reply("❗ Возникла ошибка, повторите команду! Или добавьтесь к боту!")
```
Она позволяет работать со всеми продуктами Atlassian (Confluense, ButBucket, Jira и т.д.). Достаточно понятная документация, которая описывает все методы, которые могут быть использованы с приммерами ответов.
Так же я использовал **SQLite3** базу (присутствует по умолчанию) для записи комментрариев по реквесту и последующего сравниния информации сохранненой в базе с новой (которая в реквесте). Последующий вывод, если есть изменения.
Пример начала класса, для работы с базой **SQLite3** , можно подробнее посмотреть на GitHub:
```
import sqlite3 as sq
class DataBase:
comment = int()
requests_id = list()
def connect_to_db(self) -> sq.Connection:
"""
Подключение к базе "bitbucket.db", если ее нет она будет создана
:return: connection Соединение с базой
"""
with sq.connect("bitbucket.db") as connection:
return connection
def create_cursor(self, connection) -> sq.Cursor:
"""
Создает и возвращает курсор для работы с базой
:param connection: Соединение с базой
:return: cursor Курсор
"""
cursor = connection.cursor()
return cursor
def close_db(self, connection):
"""
Закрывает соединение с базой
:param connection: Соединение с базой
:return: Закрывает соединение с базой
"""
connection.close()
def create_table(self, connection, cursor):
"""
Создает таблицу, куда будут писаться:
userId: id реквеста
userName: имя пользователя
countCm: кол-во комментариев к реквесту
:param connection: Соединение с базой
:param cursor: Курсор для работы с базой
:return: Создает таблицу
"""
cursor.execute("""CREATE TABLE IF NOT EXISTS comments(
userId INTEGER DEFAULT 0,
userName TEXT NOT NULL,
countCm INTEGER DEFAULT 0)""")
connection.commit()
```
Для отслеживания кол-ва реквестов, я записывал просто в (file.json) файл константу, которая сравнивалась с актуальным результатом кол-ва реквестов, если он был больше, значит создан новый реквест и выводил сообщение в телеграмм.
Для доп.функции сделал вывод курса валют библиотекой **Pycbrf ,** с помощью нее можно получить актуальные курсы валют на необходимые даты.
Пример:
```
from datetime import datetime
from decimal import Decimal
from pytz import timezone
from pycbrf.toolbox import ExchangeRates
class ExchangeCurrency:
_usd = str()
_eur = str()
def get_date_now(self) -> str:
saratov_tz = timezone('Europe/Moscow')
now = saratov_tz.localize(datetime.now()).strftime("%Y-%m-%d")
return now
def get_usd_currency(self) -> Decimal:
rates = ExchangeRates(self.get_date_now())
return rates['USD'].value
def get_eur_currency(self) -> Decimal:
rates = ExchangeRates(self.get_date_now())
return rates['EUR'].value
def get_currency_info(self) -> str:
usd = self.get_usd_currency()
eur = self.get_eur_currency()
return 'Курс Доллара: ' + str(usd) + ' RUB\n' + \
'Курс Евро: ' + str(eur) + ' RUB'
```
### Использование
Что бы использовать бота, предварительно, нужно его создать в телеграмме. Информации много, поэтому не буду рассказывать как это сделать.
Для работы бота в чате понадобиться **chat\_id**, что бы его унать можно вывести его в консоль, отправив сообщение ботом в чат, привязав chat\_id на вывод сообщения. Либо можно привязать вывод к выполнению команды в чат.
Для работы бота в личке, он будет получать **user\_id** из контекста. Поэтому заранее узнавать его не надо.
Для того, чтобы запустить бота нужно предварительно указать в файле Utils.py следующие параметры:
1. Токен созданного бота
2. Адрес расположения проектов в BitBucket: "https://bitbucket.corporativ\_adress.ru”
3. Логин
4. Пароль
5. Имя проекта в BitBucket
6. Название репозитория в проекте
После запуска бота, нужно его добавить в чат, далее можно узнать chat\_id, как я писал уже выше.
В личке будет работать сразу.
Милости прошу :-) Спасибо за внимание!!!
[**Ссылка на GitHub**](https://github.com/CloudKiller77/BitBucketBotPython) | https://habr.com/ru/post/710036/ | null | ru | null |
# Mesh-роутер — это просто
С того момента, когда cjdns добавили в официальный репозиторий OpenWRT, процесс подготовки mesh-роутера стал просто тривиален. Саму установку OpenWRT на роутеры описывать подробно не вижу смысла, т.к. это популярная тема. На многих официально поддерживаемых роутерах задача установки свободной прошивки сводится к простому скачиванию Factory архива и скармливанию его стандартной форме обновления прошивки на заводской системе. Главное, чтобы не было блокировки на установку сторонней прошивки, но и в этом случае, как я полагаю, будет множество обходных путей.
До появления официальной поддержки пакетов cjdns, приходилось возиться немного больше. Можно было собирать пакеты самому или искать собранные кем-то пакеты и устанавливать их. Еще были прошивки от энтузиастов с уже установленным нужных ПО. В любом случае, приходилось повозиться чуть больше, чем сейчас.
Итак, мы имеем роутер на OpenWRT, выполняющий обычные функции домашнего маршрутизатора. Администрировать все это дело будем левой кнопкой мышки в LuCY.
**Установка**
Как написал выше, OpenWrt Chaos Calmer 15.05 имеет необходимые пакеты в официальном репозитории. Заходим в меню System -> Software. Обновляем список и устанавливаем пакеты luci-app-cjdns и cjdns. Последний является зависимостью первого и должен автоматически установиться.
**Mesh режим**
После установки, cjdns сразу начнет работать. Т.е. обычная установка проходит в один шаг. Но мы хотим, чтобы роутер не только соединялся с cjdns нодами в нашей локальной сети, но и стал активным участником меш-сети. В меню появляется раздел Services -> cjdns. Во вкладке Overview отображаются все текущие соединения. Если на ваших домашних компьютерах работает cjdns, с большой вероятностью роутер установит с ними соединение в меш-режиме. Нам нужно добавить 802.11s WiFi сеть. Делается это так же просто:
идем в раздел Network -> WiFi,
на нужном физическом интерфейсе нажимаем Add,
по текущей договоренности на форуме cjdroute.net выбираем 11 канал в 2.4 ГГц,
поле Mode будет 802.11s — WiFi mesh,
Network у нее будет отдельный, т.к. нам не нужно, чтобы эти участники попадали во внутреннюю Lan сеть (я создал новый с именем Mesh),
SSID: hyperboria\_mesh,
защищать эту сеть не нужно.
В разделе Network -> Interfaces у нас появится новая сеть. Protocol я выбрал unmanaged — нам нет необходимости присваивать участникам обычные IP адреса.
Так же можно добавить простую точку доступа без защиты с именем, например, cjdroute.net, которая подключает устройства к этой сети. Это позволит подключать девайсы, не умеющие в 802.11s, но умеющие в cjdns, к hyperboria.
Теперь идем в Services -> cjdns -> Settings, спускаемся к пункту Ethernet Interfaces и добавляем там нашу новую сеть (если забыли имя, то можно подсмотреть в списке Network -> Interfaces). Beacon Mode я выбрал 2, чтобы он не только ожидал там специальные Ethernet фреймы, с помощью которых будет устанавливать mesh-соединения, но и сам рассылал такие. Так же стоит убедиться, что в домашней локальной сети тоже соединяемся. Если провайдер предоставляет локалку свою, можно попробовать и через WAN интерфейс соединяться с другими клиентами провайдера.
**Оверлэйные UDP-соединения (он же UDP транспорт)**
Естественно, глупо ожидать, что по всему городу рассыпаны уже эти коробочки, и функционирует полноценная сеть на всю страну. Тем более, что между городами крайне низкая плотность населения. Для дополнительной связи нам нужно будет добавить коннекты через UDP транспорт. Это обычный оверлэйный режим поверх других сетей типа интернета. Примерно так работает TOR. Только в данном случае, соединения будут устанавливаться напрямую без попыток анонимизации и потери скорости.
Стоит так же упомянуть о том, что здесь есть непонятый многими, но очень важный момент — необходимость добавлять такие соединения вручную и устанавливать связь с теми, с кем обменялся ключами и паролями. На первый взгляд, эта процедура идиотская и создает лишние сложности в установке: ведь в оверлэйных сетях типа Tor и I2P этого делать не надо — есть bootstrap ноды, которые передают вам список всех адресов других участников. Однако, это удобство является уязвимостью — в том же Китае к этим нодам подключаются атакующие, получают список всех участников и блокируют соединения с этими адресами и самой нодой. Т.е. удобство добавляет в систему единую точку отказа и ставит под угрозу стабильность работы вообще.
Обменяться ключами и адресами можно на том же форуме [cjdroute.net](http://cjdroute.net) в специальном разделе. Вероятно, позже, ваши друзья и коллеги тоже присоединяться к сети и обменяются с вами нужными данными.
Добавление соединений происходит так же просто в разделе Services -> cjdns -> Peers. Там можно добавить пароли для входящих подключений (помните, что для этого надо роутеру иметь белый IP адрес и открыть UPD порт) и информацию об исходящих подключениях. Каждое новое соединение увеличивает стабильность работы. А благодаря простоте интерфейса, добавлять новые можно будет между делом в течение пары минут.
На этом пункте настройку полноценного mesh-роутера можно считать завершенной. Теперь ваш роутер будет выполнять свои обычные функции домашнего маршрутизатора, но при появлении таких же сознательных соседей, будет создавать с ними новые коннекты, независимые от вашего провайдера.
**Бонусный пункт: защищенный выход в интернет**
Cjdns — это по сути решение, которое позволяет создавать распределенную виртуальную частную сеть. Благодаря своей распределенной архитектуре эта VPN вырастает в огромную Semi-meh (оверлэйная + меш) сеть и строит новый интернет будущего (Hyperboria).
Если на ваших компьютерах установлен и правильно настроен CJDNS, значит они будет «видеть» друг друга, даже если оба находятся в тысячах километрах друг от друга за провайдерскими NATами. CJDNS предоставляет IPv6, и все поддерживающие его программы будут отлично работать. Этакий хамачи здорового человека. Но кроме собственно доступа в hyperboria и соединения личных устройств в единую сеть хотелось бы в пару кликов сделать защищенный туннель в обычный интернет.
Настройки на сервере, который будет выпускать нас в интернет.
Допустим, у нас есть VPS в какой-нибудь нормальной стране, где интернет не подвергается агрессивным нападкам. Мы настроили на этом VPS такую же CJDNS ноду и хотим иметь возможность выхода через нее в интернет. Для этого в конфиге cjdns нашей VPS нужно добавить входящий туннель в разделе ipTunnel -> allowedConnections. Например:
`{
"publicKey": "kdddddgfgsftrtrtrnrmnmnmgnmdfndmfnmdfnmdnfmdfmdndfdf0.k", // Публичный ключ нашего клиента. Для роутера достаем в настройках Services -> cjdns -> Settings
"ip4Address": "192.168.45.10", // IP адрес клиента, который будет автоматически присвоен
"ip4Prefix": 24 // Префикс. Соответствует маске 255.255.255.0
}`
В консоли добавляем IPv4-адрес на интерфейс туннеля и разрешаем Forwarding, чтобы выпускать в интернет клиентов.
ip addr add dev tun0 192.168.45.1/24
echo 1 > /proc/sys/net/ipv4/conf/all/forwarding
Добавляем роут и правила для firewall
ip route add dev tun0 192.168.45.0/24
iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
iptables -A FORWARD -i eth0 -o tun0 -m state --state RELATED,ESTABLISHED -j ACCEPT
iptables -A FORWARD -i eth0 -o tun0 -j ACCEPT
Теперь наш VPS сервер может заменять нам обычные платные VPN сервисы. Кстати, по моим ощущениям, настройка Получается гораздо быстрее и проще чем того же OpenVPN.
Я на этом пункте попался в интересную ловушку. Захотел подключать сразу и роутер, и ноутбук, выдавая им разные IPv4 адреса, но в одной подсети. Как выяснилось, оно для этого не предназначено, первый вписанный клиент нормально роутился, а второй просто получал адрес, но даже не мог пинговать сервер. Если хотите несколько устройств подрубать, то надо делать разные подсети. Это может пригодиться, например, для обеспечения защищенного выхода в интернет поверх не доверенного интернет-соединения.
Настройки на роутере
Тут все просто. Идем в Services -> cjdns -> IP Tunnel и в Outgoing connections добавляем публичный ключ cjdns из конфига нашей VPS ноды. Прописанный IP присваивается автоматически. Маршрутизация клиентов роутера в интернет через этот VPN настраивается добавлением соответствующих правил на фаерволе.
Вы можете прописать адрес нашего сервера 192.168.45.1 в качестве шлюза для всех соединений, а можете просто добавлять статические роуты и перенаправлять запросы только для конкретных сайтов: Network -> Static routes
В данном случае, я сделал защищенные и устойчивые соединения для всех устройств в моей домашней сети на рутрекер и btc-e.com. По какой-то странной причине, мне захотелось сделать подключения к этим сайтам более безопасными.
В этом бонусном пункте есть и обратный вариант: сделать роутер таким сервером. Например вы находись где-то в гостях или пользуетесь общественным WiFi и хотите сделать соединения более безопасными. В той же вкладке настроек роутера добавляем входящие соединения, а на ноутбуке исходящие. Немного другие правила для роутинга — и вот вам более защищенная связь из любого места.
Таким образом, мы левой и правой кнопками мыши добились поставленных задач. На написание, возможно, банальной для хабра статьи меня сподвигла эта карта [cjdroute.net/map](http://cjdroute.net/map/). Многие добавили свое местоположение с комментарием, что готовы присоединиться, если им помогут все настроить. Во времена первых статей о CJDNS, процедура настройки была местами запутанной, а большинство мануалов подразумевали ручную сборку OpenWRT и ковыряние конфигов. Конечно, есть ряд настроек, которые хорошо бы добавить позже в консоли, но для старта достаточно описанных пунктов. Надеюсь, это может многим превратить свое желание в намерение. Если будут какие-то вопросы, мы охотно отвечаем на форуме [cjdroute.net](http://cjdroute.net) | https://habr.com/ru/post/277721/ | null | ru | null |
# Функциональный Javascript. Пишем свои линзы, часть 1
Привет, хабр.
В данной статье мы познакомимся с линзами, узнаем для чего они нужны, а также реализуем их на JavaScript.
#### Зачем нужны линзы
Начнем, пожалуй, с ответа на вопрос, зачем же нужны линзы.
В функциональном программировании широко используются неизменяемые структуры данных. Работа с ними значительно отличается по сравнению с изменяемыми данными.
В основе этого лежит тот факт, что при изменении какой-либо части неизменяемой структуры данных создается ее копия, отличающаяся от оригинала этой самой измененной частью. Полное копирование всей исходной структуры не эффективно, поэтому новая структура как правило использует ссылки на неизмененные части из оригинала.
Пример:
Пусть у нас есть структура данных:
```
var user = {
name: 'Имя пользователя',
address: {
city: 'Город',
street: 'Улица',
house: 'Дом'
}
};
```
У нас стоит задача поменять значение имени.
Если мы работаем с этой структурой как с изменяемой, то достаточно просто изменить значение в объекте user:
```
function setName(value, user) {
user.name = value;
return user;
}
```
Но если мы работаем с этой структурой как с неизменяемой, то мы не имеем право менять данные в исходном объекте. Нам нужно создать новый объект user2 в который поместить все значения из user за исключением нового name.
Вариант с полным копированием:
```
function setName(value, user) {
return {
name: value,
address: {
city: user.address.city,
street: user.address.street,
house: user.address.house
}
};
}
```
PS: Пример передает только суть. По хорошему тут должны быть проверки на то, что user != null, user.adress != null.
Вариант с частичным копированием:
```
function setName(value, user) {
return {
name: value,
address: user.address
};
}
```
Думаю схема понятна, поэтому напишем общие функции для работы со свойствами структуры:
```
//генерация гетеров
function get(prop) {
return function(item) {
return item[prop];
};
}
//генерация сетеров изменяемых структур
function setMutable(prop) {
return function(value, item) {
item[prop] = value;
return item;
}
}
//генерация сетеров для неизменяемых структур
function setImmutable(prop) {
return function(value, item) {
var props = properties(item), //получаем список всех свойств объекта
copy = props.reduce(function(lst, next) {
lst[next] = item[next];
return lst;
}, {});
copy[prop] = value; //меняем на новое значение
return copy;
};
}
//возвращает список свойств объекта obj
function properties(obj) {
var key, lst = [];
for (key in obj) {
if (obj.hasOwnProperty(key)) {
lst.push(key);
}
}
return lst;
}
```
Теперь мы можем использовать эти функции для генерации гетеров и сетеров.
Исходный пример может быть переписан так:
```
setName = setMutable('name') //Для изменяемой структуры
setName = setImmutable('name') //Для неизменяемой
getName = get('name') //Для получения имени в обоих случаях
```
Теперь предположим, что нам нужно поменять значение city у user.
Поставим задачу более обще и напишем гетеры и сетеры позволяющие работать с city через объект user.
Для изменямой структуры реализация может выглядеть так:
```
function getUserCity(user) {
return user.address.city;
}
function setUserCity(value, user) {
user.address.city = value;
return user;
}
```
Или тоже самое, но в более функциональном стиле, используя уже определенные функции get, setMutable:
```
var getAddress = get('address'),
getCity = get('city'),
getUserCity = compose(getCity, getAddress), // функция compose строит новую функцию которая по очереди (справа на лево) применяет к входящему значения функции переданные ей в качестве аргументов. Т.е. это тоже что
getUserCity = function(item) {
return getCity(getAddress(item));
},
setCity = setMutable('city'),
setUserCity = function (value, item) {
setCity(value, getAddress(item))
return item;
}
var newUser = setUserCity('новый city', user);
getUserCity(newUser) == 'новый city' // true
//P.S.
function compose(func1, func2) {
return function() {
return func1(func2.apply(null, arguments));
};
}
```
Давайте попробуем реализовать тоже для неизменямой структуры:
```
var getAddress = get('address'),
getCity = get('city'),
getUserCity = compose(getCity, getAddress),
setCity = setImmutable('city'),
setUserCity = function (value, item) {
setCity(value, getAddress(item))
return item;
};
var newUser = setUserCity('новый city', user);
getUserCity(newUser) == 'новый city' // true
```
На первый взгляд все нормально. Но обратите внимание на функцию `setUserCity`. В ней мы получаем на вход новое значение для city `value` и пользователя `item`, изменяем значение city и… возвращаем исходный объект `item`. Но это противоречит определению неизменямых структур данных. При изменении любой его части мы должны создать новый объект.
Применение функции `setUserCity` превращает наш неизменяемый объект обратно в изменяемый. Чтобы это проверить давайте выполним следующий код:
```
var newUser1 = setUserCity('city1', user),
newUser2 = setUserCity('city2', user);
newUser1 == newUser2 //true
```
Чтобы исправить это, нужно переписать значение address у пользователя `item`, и вернуть нового пользователя
```
var setAddress = setImmutable('address'),
setUserCity = function (value, item) {
var address = setCity(value, getAddress(item));
return setAddress(address, user);
},
newUser1 = setUserCity('city1', user),
newUser2 = setUserCity('city2', user);
newUser1 == newUser2 //false
```
Теперь все работает как надо.
##### Выводы:
Композиция гетеров осуществляется одинаково как для изменяемых так и для неизменяемых структур, но построение сетеров отличается значительно.
Для построения сетера глубиной n изменяемой структуры данных достаточно использования n — 1 гетеров и одного сетера с последнего уровня.
Для получения сетера неизменяемой структуры глубиной n необходимо n — 1 гетеров и n сетеров, т.к. необходимо обновлять все уровни начиная с 0 (исходный объект).
Для упрощения построения (компоновки) сетеров (и гетеров) неизменяемых структур данных удобно использовать инструмент **линзы**.
#### Линзы
Мы выяснили, что компоновка сетеров для неизменяемых структур является не тривиальной задачей, так как требует наличие списка всех гетеров и сетеров.
Но давайте введем абстракцию называемую линзой, которая есть не что иное как пара гетера и сетера:
```
var lens = Lens(getter, setter) //конструктор линзы.
```
Так же введем тривиальные операции get, set которые будут просто дублировать функционал переданных линзе гетера и сетера:
```
function Lens(getter, setter) {
return {
get: getter,
set: setter
};
}
```
А теперь давайте еще разок глянем на функцию `setUserCity`. При погружении с уровня A на уровень B нам нужны гетеры и сетеры A и B. Но мы ведь только что ввели новую абстракцию `Lens`. Почему бы композицию сетеров и гетеров по отдельности не заменить композицией их линз?
Давайте введем новую операцию на линзах `compose`, которая строит композицию двух линз:
```
function Lens(getter, setter) {
return {
compose: function (lens) {
return Lens(get2, set2);
function get2(item) {
return lens.get(getter(item));
}
function set2 (value, item) {
var innerValue = lens.set(value, getter(item));
return setter(innerValue, item);
}
},
get: getter,
set: setter
};
}
```
Давайте попробуем решить нашу задачу с использованием линз:
```
var addressLens = Lens(getAddress, setAddress), //строим линзу для адреса
cityLens = Lens(getCity, setCity), //строим линзу для города
addressCityLens = addressLens.compose(cityLens); //компонуем две линзы вместе
addressCityLens.set('новый city', user); //изменяем значение city через user, используя линзу
```
Обратите внимание на композицию линз. Она очень похожа на композицию через точку `user.address.city`. Добавление новой линзы как бы погружает нас на уровень ниже.
На практике довольно часто будет встречаться потребность к изменению значения с учетом его текущего значения, поэтому давайте расширим нашу абстракцию еще одной операцией `modify`:
```
function Lens(getter, setter) {
return {
modify: function (func, item) {
var value = getter(item);
return setter(func(value), item);
},
compose: function (lens) {
return Lens(get2, set2);
function get2(item) {
return lens.get(getter(item));
}
function set2 (value, item) {
var innerValue = lens.set(value, getter(item));
return setter(innerValue, item);
}
},
get: getter,
set: setter
};
}
```
#### Синтаксический сахар
Мы узнали что такое линзы, для чего они нужны и как ими пользоваться. Но давайте подумаем, как можно сделать работу с линзами проще.
Во первых, мало вероятно, что нам понадобится создавать линзу с гетером и сетером на разные поля (хотя это теоретически можно сделать). Поэтому давайте перегрузим конструктор линз. Он будет принимать имя свойства и автоматически генерировать для него линзу.
```
function Lens(getter, setter) {
//Если передан 1 параметр, то это название свойства
if (arguments.length == 1) {
var property = arguments[0];
getter = get(property);
setter = setImmutable(property);
}
return {
modify: function (func, item) {
var value = getter(item);
return setter(func(value), item);
},
compose: function (lens) {
return Lens(get2, set2);
function get2(item) {
return lens.get(getter(item));
}
function set2 (value, item) {
var innerValue = lens.set(value, getter(item));
return setter(innerValue, item);
}
},
get: getter,
set: setter
};
}
```
Теперь исходный пример может быть записан как:
```
Lens('address').compose(Lens('city')).set('новый city', user);
```
Создание линз облегчилось, но вот композиция выглядит довольно громоздко. Давайте напишем небольшой интерпретатор, который будет создавать линзы и строить их композицию. На вход он будет принимать список из названий свойств для которых нужно создать линзы. А операция композиции будет задаваться точкой (в лучших традициях Haskell, но в отличие от него осуществляться она будет слева направо).
Врезультате наш пример должен преобразоваться в нечто такое:
```
lens('address.city').set('новый city', user);
```
Что же, довольно близко к `user.address.city`. Давайте реализуем функцию `lens`
```
function lens(cmd) {
var lenses = cmd.split('.')
.map(pass1(Lens));
return lenses.reduce(function(lst, next) {
return lst.compose(next);
});
}
//функция которая из переданной ей на вход функции делает такую,
//которая игнорирует все переданные ей аргументы, кроме первого
function pass1(func) {
return function(x) {
return func(x);
};
}
```
Обратите внимание на функцию `pass1`. Дело в том, что `map` передает в callbaсk больше чем 1 параметр, поэтому если мы напишем `map(Lense)` то будет использоваться версия `Lense` принимающая на вход гетер и сетер. Поэтому мы оборачиваем нашу функцию `pass1`, которая гарантирует, что в `Lense` попадет только первый переданный ей параметр.
*Во второй части мы рассмотрим, как можно подружить линзы и монаду Nothing.* | https://habr.com/ru/post/230649/ | null | ru | null |
# Агрегатор событий для Unity3d (Event Aggregator)
Идея написать свой расширенный агрегатор событий для Unity3d назрела давно. Прочитав несколько статей на эту тему, я понял что нет достаточно «правильного» (в рамках Unity3d) и нужного для меня агрегатора, все решения урезаны и не обладают нужным функционалом.
### Необходимый функционал:
1. Любой класс может подписаться на любое событие (часто агрегаторы в юнити делают подписчиками конкретные Gameobject)
2. Должна быть исключена возможность двойной подписки конкретного экземпляра, на конкретное событие (в стандартных средствах за этим нужно следить самому)
3. Должен быть функционал как ручной отписки, так и автоматической, в случае удаления экземпляра/отключения монобеха (хочется подписаться и не париться что подписчик вдруг откинет копытца)
4. события должны уметь перекидывать данные/ссылки любой сложности (хочется в одну строку подписаться и получить весь комплект данных без заморочек)
### Где это применять
1. Это идеально подходит для UI, когда есть необходимость прокинуть данные от любого объекта без какой либо связанности.
2. Сообщения об изменении данных, некий аналог реактивного кода.
3. Для инъекций зависимостей
4. Глобальных колбэков
### Слабые места
1. Из за проверок на дохлых подписчиков и дублей (раскрою позже) код медленней чем аналогичные решения
2. В качестве ядра ивента используется class/struct, чтобы не аллоцировать память + верхняя проблема, не рекомендуется спамить ивентами в апдейте )
### Общая идеология
Общая идеология заключается в том, что для нас событие это конкретный и актуальный пакет данных. Допустим мы нажали кнопку на интерфейсе/джойстике. И хотим отправить ивент с признаками нажатия конкретной кнопки для последующей обработки. Результат нажатия обработки — визуальные изменения интерфейса и какое то действие в логике. Соответственно может быть обработка/подписка в двух разных местах.
**Как выглядит в моем случае тело события/пакет данных:**
**Пример тела ивента**
```
public struct ClickOnButtonEvent
{
public int ButtonID; // здесь может быть также enum клавиши
}
```
**Как выглядит подписка на ивент:**
```
public static void AddListener(object listener, Action action)
```
Для подписки нам надо указать:
Объект, который является подписчиком (обычно это сам класс в котором подписка, но это не обязательно, можно указать подписчиком один из экземпляров классов из полей класса.
Тип/ивент на который мы подписываемся. Это и есть ключевая суть данного агрегатора, для нас определенный тип класса и является событием которое мы слушаем и обрабатываем.
Подписываться лучше всего в Awake и OnEnable;
**Пример**
```
public class Example : MonoBehaviour
{
private void Awake()
{
EventAggregator.AddListener(this, ClickButtonListener);
}
private void ClickButtonListener(ClickOnButtonEvent obj)
{
Debug.Log("нажали на кнопку" + obj.ButtonID);
}
}
```
### Чтобы было понятно в чем фишка, рассмотрим более сложный случай
**У нас есть иконки персонажей которые:**
1. Знают к какому персонажу они прикреплены
2. Отражают количество маны, хп, экспы, а также статусы(оглушение, слепота, страх, безумие)
**И вот тут можно сделать несколько ивентов**
На изменение показателей:
```
public struct CharacterStateChanges
{
public Character Character;
public float Hp;
public float Mp;
public float Xp;
}
```
На изменение негативных статусов:
```
public struct CharacterNegativeStatusEvent
{
public Character Character;
public Statuses Statuses; //enum статусов
}
```
Для чего в обоих случаях мы передаем класс персонажа? Вот подписчик на ивент и его обработчик:
```
private void Awake()
{
EventAggregator.AddListener
(this, CharacterNegativeStatusListener);
}
private void CharacterNegativeStatusListener(CharacterNegativeStatusEvent obj)
{
if (obj.Character != \_character)
return;
\_currentStatus = obj.Statuses;
}
```
Это маркер по которому мы обрабатываем ивент и понимаем что именно он нам нужен.
**Почему допустим не подписаться напрямую на класс Character? И спамить им?**
Такое будет сложно дебажить, лучше для группы классов/событиый создать свой отдельный ивент.
**Почему опять же внутрь ивента просто не положить Character и брать всё с него?**
Так кстати можно, но часто в классах есть ограничения видимости, и нужные данные для ивента могут быть не видны снаружи.
**если класс слишком тяжелый чтобы использовать его в качестве маркера?**
На самом деле маркер в большинстве случаев не нужен, группа обновляемых классов — скорее редкость. Обычно в ивенте нуждается одна конкретная сущность — контроллер/модель вьюхи, которая отображает обычно состояние 1го персонажа. А так всегда есть банальное решение — ID разных типов (от инама, до сложного хэша и тд).
### Что под капотом и как это работает?
**Непосредственно код агрегатора**
```
namespace GlobalEventAggregator
public delegate void EventHandler(T e);
{
public class EventContainer : IDebugable
{
private event EventHandler \_eventKeeper;
private readonly Dictionary> \_activeListenersOfThisType = new Dictionary>();
private const string Error = "null";
public bool HasDuplicates(object listener)
{
return \_activeListenersOfThisType.Keys.Any(k => k.Target == listener);
}
public void AddToEvent(object listener, EventHandler action)
{
var newAction = new WeakReference(listener);
\_activeListenersOfThisType.Add(newAction, action);
\_eventKeeper += \_activeListenersOfThisType[newAction];
}
public void RemoveFromEvent(object listener)
{
var currentEvent = \_activeListenersOfThisType.Keys.FirstOrDefault(k => k.Target == listener);
if (currentEvent != null)
{
\_eventKeeper -= \_activeListenersOfThisType[currentEvent];
\_activeListenersOfThisType.Remove(currentEvent);
}
}
public EventContainer(object listener, EventHandler action)
{
\_eventKeeper += action;
\_activeListenersOfThisType.Add(new WeakReference(listener), action);
}
public void Invoke(T t)
{
if (\_activeListenersOfThisType.Keys.Any(k => k.Target.ToString() == Error))
{
var failObjList = \_activeListenersOfThisType.Keys.Where(k => k.Target.ToString() == Error).ToList();
foreach (var fail in failObjList)
{
\_eventKeeper -= \_activeListenersOfThisType[fail];
\_activeListenersOfThisType.Remove(fail);
}
}
if (\_eventKeeper != null)
\_eventKeeper(t);
return;
}
public string DebugInfo()
{
string info = string.Empty;
foreach (var c in \_activeListenersOfThisType.Keys)
{
info += c.Target.ToString() + "\n";
}
return info;
}
}
public static class EventAggregator
{
private static Dictionary GlobalListeners = new Dictionary();
static EventAggregator()
{
SceneManager.sceneUnloaded += ClearGlobalListeners;
}
private static void ClearGlobalListeners(Scene scene)
{
GlobalListeners.Clear();
}
public static void AddListener(object listener, Action action)
{
var key = typeof(T);
EventHandler handler = new EventHandler(action);
if (GlobalListeners.ContainsKey(key))
{
var lr = (EventContainer)GlobalListeners[key];
if (lr.HasDuplicates(listener))
return;
lr.AddToEvent(listener, handler);
return;
}
GlobalListeners.Add(key, new EventContainer(listener, handler));
}
public static void Invoke(T data)
{
var key = typeof(T);
if (!GlobalListeners.ContainsKey(key))
return;
var eventContainer = (EventContainer)GlobalListeners[key];
eventContainer.Invoke(data);
}
public static void RemoveListener(object listener)
{
var key = typeof(T);
if (GlobalListeners.ContainsKey(key))
{
var eventContainer = (EventContainer)GlobalListeners[key];
eventContainer.RemoveFromEvent(listener);
}
}
public static string DebugInfo()
{
string info = string.Empty;
foreach (var listener in GlobalListeners)
{
info += "тип на который подписаны объекты " + listener.Key.ToString() + "\n";
var t = (IDebugable)listener.Value;
info += t.DebugInfo() + "\n";
}
return info;
}
}
public interface IDebugable
{
string DebugInfo();
}
}
```
**Начнем с основного**
Это словарь в котором ключ тип, а значение — контейнер
```
public class EventContainer : IDebugable
```
```
private static Dictionary GlobalListeners = new Dictionary();
```
Почему мы храним контейнер в виде object? Словарь не умеет хранить дженерики. Но за счёт ключа мы имеем возможность оперативно привести объект к нужному нам типу.
**Что содержит контейнер?**
```
private event EventHandler \_eventKeeper;
private readonly Dictionary> \_activeListenersOfThisType = new Dictionary>();
```
Он содержит дженерик мультиделегат и коллекцию где ключом выступает как раз тот объект подписчик, а значение этот тот самый метод обработчик. По факту этот словарь содержит все объекты и методы которые принадлежат этому типу. В итоге мы вызываем мультиделегат, а он вызывает всех подписчиков, это «честная» ивент система, в которой нет ограничений на подписчика, в большинстве же других агрегаторов под капотом итерируется коллекция классов, которые обобщены либо специальным интерфейсом, либо наследуются от класса который реализует систему сообщений.
При вызове мультделегата происходит проверка — есть ли дохлые ключи, чистится коллекция от трупов, и потом инвочится мультиделегат с актуальными подписчиками. Это отнимает время, но опять же по факту, если функционал ивентов сепарирован, то у одного ивента будет 3-5 подписчиков, поэтому проверка не так страшна, выгода от комфорта очевиднее. Для сетевых историй где подписчиков может быть тысяча и более — этот агрегатор лучше не использовать. Хотя тут остается открытым вопрос — если убрать проверку на трупы, что быстрее — итерация по массиву подписчиков из 1к или вызов мультиделегата с 1к подписчиков.
### Особенности пользования
Подписку лучше всего пихать в Awake.
Если объект активно включается/выключается, лучше подписаться и в Awake и OnEnable, он не подпишется дважды, но будет исключена возможность что неактивный GameObject примут за дохлый.
Инвочить события лучше не раньше старта, когда все подписчики будут созданы и зарегестрированы.
Агрегатор чистит список на выгрузке сцены. В некоторых агрегаторах предлагается чистить на загрузке сцены — это фейл, ивент загрузки сцены приходит после Awake/OnEnable, добавленные подписчики будут удалены.
У агрегатора есть — public static string DebugInfo(), можно посмотреть какие классы на какие ивенты подписаны.
[**Репозиторий на GitHub**](https://github.com/Brightori/CodeExamples) | https://habr.com/ru/post/446130/ | null | ru | null |
# Группировка моделей телефонов Android по контейнерам Docker
#### Немного предыстории
Мобильное приложение Badoo существует для основных «нативных» платформ (Android, iOS и Windows Phone) и для мобильного веба. Несмотря на то, что в разработке мы не используем никаких кроссплатформенных фрэймворков, подавляющая часть бизнес-логики в приложениях схожа, и чтобы не дублировать функциональные тесты для всех платформ, мы пишем кроссплатформенные тесты с помощью Cucumber, Calabash и Appium. Это позволяет нам выносить в общую часть и переиспользовать в тестах для всех платформ код, отвечающий за проверку этой самой бизнес-логики. Различной же остается лишь реализация взаимодействия с приложением (более подробно мы рассказывали об этом [здесь](https://techblog.badoo.com/blog/2015/07/07/cross-platform-mobile-test-automation-and-continuous-delivery/)).
Когда кроссплатформенная автоматизация только начиналась (на iOS и Android), было принято решение использовать в качестве серверов Mac Mini. Это позволило сделать каждую из 8 билд-машин универсальной: на ней можно было собирать и запускать функциональные и юнит-тесты как для приложений на iOS, так и на Android. Такое решение устраивало нас практически всем до тех пор, пока количество функциональных тестов не перевалило за пять сотен для каждой платформы, а прогоны не стали требовать все больше времени. Для того чтобы удержать время прогона в разумных границах, мы постоянно работаем над оптимизацией тестов, а также добавляем новые Android-устройства (для iOS мы добавляем симуляторы по-другому). Со временем у нас появились Mac Mini с более чем 8 смартфонами. Важно отметить, что мы подключаем устройства одной модели к одному серверу, чтобы прогоны тестов были консистентны на одном агенте.
#### По существу
У себя в Badoo мы решили перенести тестирование устройств Android на Linux-хосты — необходимое оборудование стоит дешевле, а кроме того, компьютеры Mac Mini, используемые для сборки, часто прерывают USB-подключения к устройствам Android, и те внезапно исчезают во время тестирования. Для управления серверами Linux мы в основном используем контейнеры Docker, поэтому решили попробовать создать контейнер для тестирования реальных устройств Android и клонировать его для каждой модели или группы телефонов, чтобы интегрировать контейнер в существующую конфигурацию серверов.
Небольшое замечание: одно из преимуществ Linux по сравнению с Mac заключается в том, что Linux — открытая система. Она показала нам, что причина таинственного исчезновения телефонов при тестировании кроется в разрывах соединений, длящихся доли секунды. Мы исправили тесты, добавив в них повторную попытку подключения, что в значительной степени решило проблему.
#### По существу: Docker
Docker — это система, которая содержит в себе методы сборки и распространения конфигураций ПО с инфраструктурой операционной системы, изолирующей каждый программный контейнер от остальных компонентов компьютера. Контейнер имеет собственную файловую систему, адресное пространство и пр. Контейнеры исполняются в одном экземпляре операционной системы, но поскольку система сильнее изолирует процессы, это все работает как набор виртуальных машин.
Поясняющие диаграммы, опубликованные на сайте Docker:
На хост-компьютере используется система виртуализации, в которой запущены гостевые экземпляры ОС:
Контейнеры Docker выполняются на одной ОС:
#### По существу: группировка adb/adbd
Каждый контейнер должен был управлять собственным набором телефонов. Чтобы реализовать это наиболее естественным способом, нужно сопоставить группы разъемов USB разным контейнерам. Устройства, подключенные к разъемам на передней панели компьютера, появляются в каталоге /dev/bus/usb/001, который доступен контейнеру 1; устройства, подключенные к разъемам на задней панели, появляются в каталоге /dev/bus/usb/002, который доступен контейнеру 2. Чтобы увеличить количество подключаемых устройств, была заказана дополнительная плата расширения.
Все это выглядит неплохо, однако команда adb взаимодействует с телефоном через демон, который использует порт по умолчанию 5037 и работает на уровне всего компьютера. Это означает, что первый контейнер, в котором выполняется команда adb, запускает и демон adb (adbd) — в результате остальные контейнеры, подключаемые к этому демону, видят телефоны первого контейнера. Эту проблему можно было бы решить с помощью сетевых возможностей Docker (каждый контейнер получает собственный IP-адрес, а, следовательно, и собственный набор портов), однако мы воспользовались другим механизмом. Для каждого контейнера было присвоено отдельное значение переменной окружения ANDROID\_ADB\_SERVER\_PORT. Мы выделили порт каждому контейнеру, чтобы он запускал собственный демон adb, который видит только телефоны этого контейнера.
В процессе разработки мы поняли, что нельзя выполнять команду adb на уровне хоста, не задав переменную ANDROID\_ADB\_SERVER\_PORT, поскольку демон adbd уровня хоста, способный видеть все порты USB, «крадет» телефоны у контейнеров Docker (телефоны могут взаимодействовать только с одним демоном adbd в каждый момент времени).
Если бы мы использовали только эмуляторы, можно было бы обойтись отдельными процессами adbd, но поскольку мы работаем с реальными устройствами…
#### По существу: обновление контейнеров при горячем подключении устройств USB
Вторая проблема (и главная причина написания этой статьи) заключалась в том, что при перезагрузке телефона во время обычной процедуры сборки он исчезал из файловой системы и списка телефонов контейнера и больше не появлялся!
Отслеживать добавление и удаление телефонов на хост-компьютере можно по файлам в каталоге /dev/bus/usb, в котором система создает и удаляет файлы, соответствующие телефонам:
```
while sleep 3; do
find /dev/bus/usb > /tmp/a
diff /tmp/a /tmp/b
mv /tmp/a /tmp/b
done
```
К сожалению, в контейнерах Docker телефоны не только не создаются и не удаляются подобным образом; если настроить создание и удаление узлов, то они на самом деле не взаимодействуют с телефонами!
Мы решили этот вопрос «в лоб»: поместили контейнеры в режим **--privileged** и открыли им доступ ко всему каталогу /dev/bus/usb.
Теперь понадобился другой механизм распределения телефонов по интерфейсным шинам. Я скачал исходный код Android и внес небольшие изменения в файл platform/system/core/adb/usb\_linux.cpp
```
std::string bus_name = base + "/" + de->d_name;
+ const char* filter = getenv("ADB_DEV_BUS_USB");
+ if (filter && *filter && strcmp(filter, bus_name.c_str())) continue;
std::unique_ptr dev\_dir(opendir(bus\_name.c\_str()), closedir);
if (!dev\_dir) continue;
```
Переменной ADB\_DEV\_BUS\_USB присваивается отдельное значение для каждого контейнера, указывающее на шину, с которой должен работать контейнер.
Отступление: хотя исправление было совсем несложным, сборку adb пришлось выполнять методом проб и ошибок, поскольку большинство людей включает в сборку все подряд. Мое окончательное решение выглядело так (в чувствительной к регистру файловой системе — я работаю на Mac):
```
cd src/android-src
source build/envsetup.sh
lunch 6
vi system/core/adb/usb_linux.cpp
JAVA_NOT_REQUIRED=true make adb
out/host/linux-x86/bin/adb
```
#### По существу: мультиплексирование портов USB
Дела шли неплохо, но после установки платы расширения USB мы обнаружили, что на ней только одна шина USB — на компьютере теперь три шины, а у нас пять групп устройств.
Поскольку я уже влез в код adb, то решил просто добавить еще одну переменную окружения: переменная ADB\_VID\_PID\_FILTER получает список пар идентификаторов vid:pid, и adb игнорирует любые несоответствующие устройства.
Исправление приведено ниже. При сканировании шины USB для обнаружения подключенных телефонов процессы adbd могут вступить в состояние гонки, однако на практике это не вызывает проблем.
```
diff --git a/adb/usb_linux.cpp b/adb/usb_linux.cpp
index 500898a..92e15ca 100644
--- a/adb/usb_linux.cpp
+++ b/adb/usb_linux.cpp
@@ -115,6 +115,71 @@ static inline bool contains_non_digit(const char* name) {
return false;
}
+static int iterate_numbers(const char* list, int* rejects) {
+ const char* p = list;
+ char* end;
+ int count = 0;
+ while(true) {
+ long value = strtol(p, &end, 16);
+//printf("%d, %p ... %p (%c) = %ld (...%s)\n", count, p, end, *end, value, p);
+ if (p == end) return count;
+ p = end + 1;
+ count++;
+ if (rejects) rejects[count] = value;
+ if (!*end || !*p) return count;
+ }
+}
+
+int* compute_reject_filter() {
+ char* filter = getenv("ADB_VID_PID_FILTER");
+ if (!filter || !*filter) {
+ filter = getenv("HOME");
+ if (filter) {
+ const char* suffix = "/.android/vidpid.filter";
+ filter = (char*) malloc(strlen(filter) + strlen(suffix) + 1);
+ *filter = 0;
+ strcat(filter, getenv("HOME"));
+ strcat(filter, suffix);
+ }
+ }
+ if (!filter || !*filter) {
+ return (int*) calloc(sizeof(int), 1);
+ }
+ if (*filter == '.' || *filter == '/') {
+ FILE *f = fopen(filter, "r");
+ if (!f) {
+ if (getenv("ADB_VID_PID_FILTER")) {
+ // Only report failure for non-default value
+ printf("Unable to open file '%s'\n", filter);
+ }
+ return (int*) calloc(sizeof(int), 1);
+ }
+ fseek(f, 0, SEEK_END);
+ long fsize = ftell(f);
+ fseek(f, 0, SEEK_SET); //same as rewind(f);
+ filter = (char*) malloc(fsize + 1); // Yes, it's a leak.
+ fsize = fread(filter, 1, fsize, f);
+ fclose(f);
+ filter[fsize] = 0;
+ }
+ int count = iterate_numbers(filter, 0);
+ if (count % 2) printf("WARNING: ADB_VID_PID_FILTER contained %d items\n", count);
+ int* rejects = (int*)malloc((count + 1) * sizeof(int));
+ *rejects = count;
+ iterate_numbers(filter, rejects);
+ return rejects;
+}
+
+static int* rejects = 0;
+static bool reject_this_device(int vid, int pid) {
+ if (!*rejects) return false;
+ for ( int len = *rejects; len > 0; len -= 2 ) {
+//printf("%4x:%4x vs %4x:%4x\n", vid, pid, rejects[len - 1], rejects[len]);
+ if ( vid == rejects[len - 1] && pid == rejects[len] ) return false;
+ }
+ return true;
+}
+
static void find_usb_device(const std::string& base,
void (*register_device_callback)
(const char*, const char*, unsigned char, unsigned char, int, int, unsigned))
@@ -127,6 +192,8 @@ static void find_usb_device(const std::string& base,
if (contains_non_digit(de->d_name)) continue;
std::string bus_name = base + "/" + de->d_name;
+ const char* filter = getenv("ADB_DEV_BUS_USB");
+ if (filter && *filter && strcmp(filter, bus_name.c_str())) continue;
std::unique_ptr dev\_dir(opendir(bus\_name.c\_str()), closedir);
if (!dev\_dir) continue;
@@ -176,6 +243,12 @@ static void find\_usb\_device(const std::string& base,
pid = device->idProduct;
DBGX("[ %s is V:%04x P:%04x ]\n", dev\_name.c\_str(), vid, pid);
+ if(reject\_this\_device(vid, pid)) {
+ D("usb\_config\_vid\_pid\_reject");
+ unix\_close(fd);
+ continue;
+ }
+
// should have config descriptor next
config = (struct usb\_config\_descriptor \*)bufptr;
bufptr += USB\_DT\_CONFIG\_SIZE;
@@ -574,6 +647,7 @@ static void register\_device(const char\* dev\_name, const char\* dev\_path,
static void device\_poll\_thread(void\*) {
adb\_thread\_setname("device poll");
D("Created device thread");
+ rejects = compute\_reject\_filter();
while (true) {
// TODO: Use inotify.
find\_usb\_device("/dev/bus/usb", register\_device);
```
Надеюсь, что мои идеи пригодятся вам, если вы реализуете похожий проект. Оставляйте вопросы в комментариях ниже.
*Tim Baverstock,
QA automation engineer* | https://habr.com/ru/post/309104/ | null | ru | null |
# Микрозаметка: Итераторы/Генерация диапазонов дат, чисел и тд
Эта заметка навеяна топиком "[подсчет количества событий календаря в каждом месяце года](http://habrahabr.ru/blogs/mysql/106793/)". В ней нет ничего нового, это просто микрозаметка о возможных решениях.
Хотя задача того топика очень типична и вполне спокойно решалась обычным проходом с case или if:
> `SELECT
>
> sum(
>
> CASE
>
> when t.`start\_date`<'2010-02-01' and t.end\_date>'2010-01-01' then 1
>
> else 0
>
> end
>
> )
>
> AS jan,
>
> sum(
>
> CASE
>
> when t.`start\_date`<'2010-03-01' and t.end\_date>'2010-02-01' then 1
>
> else 0
>
> end
>
> )
>
> AS feb,
>
> ...
>
> FROM test t`
Но я счел нужным написать о некоторых возможностях избежать излишнюю ручную работу. Например, если нам необходимо бы было агрегировать не за год и не за два, а, скажем, за последние 5 лет помесячно. Согласитесь, в таком случае 60 строк c if'ами было бы как минимум тяжело читать.
[JayDi](https://habrahabr.ru/users/jaydi/) [шел в правильном направлении](http://habrahabr.ru/blogs/mysql/106793/#comment_3361207) говоря о табличке для дат, но ее бы пришлось отдельно создавать да еще и с конкретными условиями(подневно, помесячно или посекундно и тд)… Этот способ даже [используют иногда](http://datacharmer.blogspot.com/2006/06/filling-test-tables-quickly.html).
В принципе я не имею ничего против создания temporary tables, но в данном случае они совершенно излишни. В Oracle, например, генерацию таких временных диапазонов-счетчиков можно сделать как угодно, например, "*select rownum from dual connect by rownum", или создав pipelined-функцию, или используя типы из dbms\_sql, или [используя коллекции](http://www.xt-r.com/2010/10/1-oracle.html). В mysql, к сожалению, нет «connect by», но есть information\_schema — аналог ораклового data dictionary, а ораклисты довольно часто используют для тестовых прогонов запросы вида "**select rownum from all\_objects**". Таким же образом можем поступить и мы:
Выборка для группировки и джойна для 10 месяцев с начала 2010:
> `--set @rownumber:=0;
>
> select
>
> case
>
> when @rownumber is null
>
> then @rownumber:=1
>
> else @rownumber:=@rownumber+1
>
> end n,
>
> DATE\_FORMAT(
>
> date\_add('2010-01-01', interval @rownumber month),
>
> '%Y.%m') month
>
> from
>
> information\_schema.columns t
>
> limit 10
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Здесь используется просто в качестве генератора строк табличка information\_schema.column, которую можно заменить на любую другую, которая в основном не используется и в которой гарантированно достаточно строк для нашего запроса(в моем случае, например, их 5281). Первая закомментированная строка должна быть выполнена для обнуления переменной-счетчика.
Получим:
```
n month
1 2010.01
2 2010.02
3 2010.03
4 2010.04
5 2010.05
6 2010.06
7 2010.07
8 2010.08
9 2010.09
10 2010.10
```
Теперь эту таблицу вы можете сджойнить с вашей таблицей по вашим условиям. В случае, если заранее не знаете необходимого кол-ва месяцев(строк), то вместо limit ограничьте условиями минимальной и максимальной даты.
Другой вариант решения: решение «в лоб» — использование курсоров. Ну, что может быть логичнее, чем создать процедуру с использованием курсоров в случае, если нам необходимо собрать более сложные аггрегаты, чем встроенные? Этот вопрос я даже не буду описывать(можете почитать, например, [тут](http://habrahabr.ru/blogs/mysql/46333/)), но не забывайте про них(в том топике никто об этом даже не вспомнил...)* | https://habr.com/ru/post/106815/ | null | ru | null |
# Резервирование и аварийное восстановление с помощью Zextras Backup
Одной из главных задач, которая встает перед системным администратором при внедрении любой информационной системы — обеспечение сохранности хранящихся в ней данных. Наиболее оптимальным способом добиться этой цели является резервирование, которое позволяет при минимальных затратах всегда иметь на руках инструменты для восстановления работоспособности системы даже в случае достаточно масштабного сбоя.
Наиболее продвинутым инструментом резервирования для Zimbra OSE на сегодняшний день является Zextras Backup, входящий в состав решения Zextras Suite Pro и Zextras Suite Basic. В нем реализовано транзакционное резервирование, которое в реальном времени отслеживает каждое происходящее в Zimbra OSE изменение и резервирует все транзакции. Благодаря этому в резервной копии помимо самих данных сохраняется история их изменений и при восстановлении информации из резервной копии можно воссоздать любой почтовый ящик, любой домен или даже почтовый сервер такими, какими они были на определенный момент времени.
### Исходные данные
В данной статье демонстрируется работа Zextras Backup на примере Zimbra 9 OSE от Zextras в односерверном режиме. Показанные функции работают только при наличии действующей лицензии Zextras Suite Pro или Zextras Suite Basic. Для её приобретения вы можете связаться с официальным представителем Zextras в России Екатериной Триандафилиди по электронной почте katerina@zextras.com.
### Инициализация резервирования
После установки свежей версии Zextras Suite, в консоли администратора Zimbra OSE появится новый раздел под названием Zextras, где будут находиться модули, предоставляемые Zextras Suite. Среди них:
* Ядро — Здесь собрана информация о работе модулей Zextras Suite, обновлениях, оповещениях и так далее. Кроме того, именно в этом разделе производится доустановка модулей Zextras Team, Zextras Docs и Zextras Drive
* Admin — Здесь можно управлять списком делегированных администраторов, а также квотами доменов
* Backup — Здесь собраны настройки резервирования
* Mobile — Здесь можно найти настройки синхронизации с мобильными устройствами по протоколу Exchange ActiveSync и перечень мобильных устройств, которые подключаются к серверу.
* ZxPowerstore — Здесь собраны настройки иерархической структуры хранения данных. В частности, можно подключить к серверу вторичные и индексные тома и настроить политику хранения данных
* Оповещения — здесь отображается список всех оповещений от Zextras Suite. Они включают в себя оповещения о начале и завершении операций, возникающих ошибках и истечении срока лицензии.
Нас интересует раздел Backup. В первую очередь нам необходимо инициализировать резервирование. По умолчанию файлы резервной копии будут хранится в /opt/zimbra/backup/zextras/.
При желании путь к резервной копии можно изменить на любой другой. Для этого нужно в разделе Backup ввести новый путь к папке с резервной копией и нажать на кнопку «Сохранить» в правом верхнем углу. После смены пути хранения резервной копии нужно повторно инициализировать резервирование.
Обращаем ваше внимание на то, что инициализация резервирования пройдет успешно только в том случае, если у пользователя zimbra есть права на чтение и запись в указанную папку. Сразу после инициализации резервирования начинает работать сканер реального времени, который автоматически резервирует каждую происходящую на сервере Zimbra OSE транзакцию.
О том, что резервирование было успешно завершено, можно узнать в разделе “Оповещения”. В том случае, если при резервировании возникнет ошибка, в тексте уведомления будет сообщено о том, что именно произошло. Наиболее распространенной ошибкой является отсутствие прав на запись в папке, куда сохраняется резервная копия.
Сейчас мы используем односерверную установку Zimbra OSE и резервируем все данные на тот же носитель, на котором расположен сам сервер Zimbra. Это не очень правильное решение с точки зрения безопасности данных, так как в том случае, если носитель физически повредится, данные окажутся зашифрованными или произойдет сбой в файловой системе, под ударом окажется не только сам сервер Zimbra OSE, но и его резервная копия. Для того, чтобы этого избежать, следует использовать отдельное устройство для хранения резервной копии.
**Подключение отдельного устройства для хранения резервных копий**
Наиболее простым способом сделать это является подключение дополнительного устройства к серверу и монтирование его в папку, куда сохраняются резервные копии. Для того, чтобы узнать, как идентифицируется подключенное устройство, следует воспользоваться командой **sudo fdisk -l**.
В нашем случае, помимо основного sda-устройства, а также множества loop-устройств, появилось устройство /dev/sdb1. Обращаем ваше внимание на то, что перед его монтированием необходимо остановить резервирование, если оно осуществляется на вашем сервере.
Смонтировать устройство можно двумя путями. Первый — при помощи команды mount в командной строке от имени пользователя zimbra. В нашем случае эта команда будет выглядеть так:
```
sudo mount /dev/sdb1 /opt/zimbra/backup/zextras/
sudo chmod -R -v 777 /opt/zimbra/backup/zextras/*
```
Затем, чтобы каждый раз не монтировать устройство вручную, можно прописать параметры автоматического монтирования диска в файле /etc/fstab.
Также для монтирования устройства можно воспользоваться приложением «Диски», которое входит в дистрибутив Ubuntu 18.04 по умолчанию. В нем нужно выбрать устройство, предназначенное для резервирования, перейти в его настройки и указать точку монтирования. В нашем случае это /opt/zimbra/backup/zextras/. А если установить галочку «Подключать при запуске системы», то устройство самостоятельно будет подключаться даже в случае перезагрузки системы.
В результате резервная копия данных на сервере Zimbra OSE останется целой и невредимой даже в том случае, если устройство, на котором хранятся файлы операционной системы выйдет из строя по обозначенным причинам.
В данном примере осуществляется подключение к серверу физического устройства, однако по тому же принципу можно подключить и сетевые хранилища. Важно лишь, чтобы скорость записи данных была достаточно хорошей.
### Имитация аварии
Для того, чтобы проверить работу резервирования, воссоздадим аварию на сервере. Для этого сперва на исходном сервере контрольного пользователя под названием Backup.
Войдем с его идентификационными данными в веб-клиент и:
* Отправим письмо от его имени
* Пришлем ему письмо
* Сохраним одно из писем в черновиках
* Создадим новую задачу
* Создадим новую встречу
* Создадим новый контакт
Таким образом, наша контрольная учетная запись будет иметь сразу несколько компонентов для резервирования и можно будет проверить, что из этого будет восстановлено при резервировании.
Следующим шагом станет имитация потери данных. Фактически, мы просто отформатируем раздел с Ubuntu 18.10, на котором установлена Zimbra OSE 9. Таким образом утерянными окажутся не только данные операционной системы, но и исходные данные почтового сервера.
### Восстановление данных
Для того, чтобы начать восстановление данных, необходимо повторно установить Ubuntu 18.04 и развернуть на ней Zimbra OSE 9 с тем же доменом, что и раньше. Данный процесс весьма подробно описан [в нашей предыдущей статье](https://habr.com/ru/company/zimbra/blog/522594/). Также необходимо установить Zextras Suite и воспользоваться ранее зарезервированным файлом лицензии.
После того, как почтовый сервер вновь работает, остается лишь восстановить данные из резервной копии. Поскольку все данные сохранялись на отдельном устройстве, можно подключить его к новому серверу и восстановиться из хранящейся на нем резервной копии.
Для этого необходимо создать папку, в которую будет монтироваться диск с резервной копией старого сервера и подключить устройство.
```
sudo su - zimbra
mkdir /opt/zimbra/backup_old
sudo mount /dev/sdb1 /opt/zimbra/backup_old/
```
После этого необходимо перейти в консоль администрирования на новом сервере и в разделе Backup нажать на кнопку «Импорт резервной копии» в нижней части экрана.
В открывшемся мастере импорта резервной копии необходимо:
* Указать путь к резервной копии со старого сервера (в нашем случае это /opt/zimbra/backup\_old)
* Указать домены, которые подлежат восстановлению
* Указать учетные записи, которые подлежат восстановлению
Также мастер позволяет отказаться от восстановления системных учетных записей, таких как galsync, удаленных учетных записей, псевдонимов, списков рассылки и классов обслуживания. В том случае, если речь идет о реальной аварии и счет идет на минуты, отказ от восстановления этих элементов может быть очень кстати.
После того как все нужные параметры будут указаны, можно будет настроить адреса для рассылки уведомлений о завершении процедуры импорта данных из резервной копии.
### Проверка результата
Для проверки результата попробуем войти под именем ранее созданного пользователя Backup. Поскольку вход удался, это означает, что аутентификационные данные учетной записи успешно восстановились.
Теперь удостоверимся, что в его учетной записи сохранились все ранее созданные элементы: входящие и исходящие письма, черновики, созданные события и задачи.
Как видно на скриншотах, все элементы находятся в целости и сохранности. Таким образом, аварийное восстановление сервера Zimbra OSE 9 с помощью Zextras Backup прошло успешно.
По всем вопросам, связанными c Zextras Suite вы можете обратиться к Представителю компании «Zextras» Екатерине Триандафилиди по электронной почте ekaterina.triandafilidi@zextras.com | https://habr.com/ru/post/526584/ | null | ru | null |
# shared hotspare для mdadm
(сомневался сюда писать или в системное администрирование)
Я обнаружил, что в интернете очень мало (и не очень внятно) объяснено, как mdadm работает с общими (глобальными) дисками горячей подмены. В заметке я опишу, что это такое, и объясню, почему shared hotspare не отмечены в /proc/mdstat как общие, а вместо этого выглядят как вполне себе локальные.
Что такое hot-spare?
====================
(Я пишу не для новичков, так что галопом по европам)
Если массив обладает избыточностью и один из его дисков вышел из строя, то существует возможность восстановить избыточную информацию на резервный диск. Если диск добавляется в массив руками (админу пришло письмо о сбое, он прочитал письмо, проснулся/оделся, приехал на работу, вынул сбойный диск, вставил запасной, добавил его в массив, дал команду на восстановление избыточности), то такой диск называется cold-spare. Просто «запасной диск».
Если же в сервере есть простаивающий диск, на который осуществляется восстановление избыточности сразу после сбоя любого из дисков массива, то такой диск называется hot-spare. Главное достоинство — оно отребилдится (восстановит избыточность) даже если админ письмо прозевал или не успел вовремя приехать.
Локальные hot-spare
===================
Обычно запасной диск добавляется для массива, то есть если в массиве сбой, то его резервный диск и используется. Если сбой происходит в соседнем массиве, то hot-spare из «чужого» массива не используется.
Это на самом деле логично — если у нас стоит выбор — использовать hot-spare для восстановления избыточности системного раздела или раздела с данными, то надо восстанавливать избыточность раздела с данными. А если системный раздел уже «занял» hot-spare, то будет бяка. Более того, некоторые производители предлагают 1EE hotspare, в которой резервный диск используется и для хранения данных (пустое место «размазано» между дисками массива, обеспечивая возможность быстрого ребилда и увеличивая производительность в нормальном режиме).
Глобальные (общие) hot-spare
============================
Однако, бывает так, что массивов с данными много. И им всем нужны hot-spare диски. Но дисков жалко. И тогда возникает желание иметь «общий» диск, который может быть использован для любого из массивов (а ещё лучше 2-3 таких диска).
Это было вступление. Теперь переходим к сути вопроса.
linux md
========
mdadm (ядерный модуль в DM-стеке) не поддерживает shared hot-spare. Диск может быть добавлен как hot-spare только в конкретный массив.
Но mdadm поддерживает!
======================
Именно так. mdadm поддерживает, ядерный модуль — нет. Mdadm реализует общий hot-spare методом «перекинуть hotspare с одного массива на другой, повреждённый».
Другими словами, для того, чтобы это сработало, должен быть запущен mdadm в режиме -F (follow). Он же обычно присылает сообщения на почту о проблемах рейда. Большинство современных дистрибутивов его запускают (если есть массивы), но, важно понимать, что он обслуживает только те массивы, которые были собраны из mdadm.conf, а не собранные ручками. (Да-да, тут нас ждёт подстава).
spare-group
===========
Для возможности распределять диски между разными массивами есть понятие spare-group, то есть группа, в пределах которой возможно перекидывание дисков. Таких групп может быть много — и hot-spare переносятся только между ними.
Как легко понять из вышенаписанного про mdadm/linux md, в /proc/mdstat нет и не может быть ничего про spare-group. Потому что это личные мысли и соображения mdadm'а, а ядро про это ни сном, ни духом (файлы-то в /proc создаются модулями ядра...).
Таким образом, обеспечивать shared hot-spare можно только с с помощью mdadm. Тут два варианта: если группа указана для массива, собирающегося при загрузке (/etc/mdadm/mdadm.conf), то там можно указать hot-spare, примерно так:
> ARRAY /dev/md1 level=raid1 num-devices=2 metadata=1.2 spares=1 spare-group=myhostparegroupname name=server:1 UUID=18219495:03fda335:3f1ad1ee:a5f5cd44
>
> devices=/dev/sda,/dev/sdb,/dev/sdc
>
> ARRAY /dev/md2 level=raid1 num-devices=2 metadata=1.2 spare-group=myhostparegroupname name=server:2 UUID=18219495:03fda335:3f1ad1ee:a5f5cd45
>
> devices=/dev/sdd,/dev/sde
>
>
(сразу отвечаю на вопрос, где столько умных слов взять — `mdadm --detail --scan --verbose`)
Дописано по сравнению с выводом mdadm тут только spare-group. Обратите внимание — во втором массиве НЕТ hot-spare, однако, т.к. группа указана, то в случае сбоя будет использоваться диск из другого массива с той же самой группой. В нашем случае это будет /dev/md1.
Разумеется, всё это произойдёт, только если у нас есть запущенный в режиме -F mdadm. В debian он в выводе ps выглядит так:
```
/sbin/mdadm --monitor --pid-file /var/run/mdadm/monitor.pid --daemonise --scan --syslog
```
Самих групп при этом на одной системе может быть несколько.
Кстати, тут есть мелкая гадость: при вызове mdadm с --detail упоминания о spare-groups не будет, их нужно будет дописывать самим.
Local && global hotspare
========================
А вот тут, увы, йок. Насколько я знаю, mdadm не поддерживает одновременно и локальные (которые будут принадлежать только одному массиву) и общие hotspare. Если есть два массива с одним spare-group, то все hot-spare из одного массива могут быть использованы на благо другого.
Сценарий не такой редкий, как кажется. Вот простенькая топология:
SYS\_ARRAY
DATA\_ARRAY
2 hot-spare
Логично было бы один hot-spare сделать принадлежащим только DATA\_ARRAY, а второй сделать общим, чтобы использовался и как резерв для SYS\_ARRAY, и как «второй уровень резерва» для DATA\_ARRAY.
Увы, увы, увы, этого нет (если меня разубедят в комментариях, я буду очень рад). | https://habr.com/ru/post/122379/ | null | ru | null |
# ШОК! Новый софт для фишинга побеждает второй фактор
Всем привет!
Бывают случаи, когда тебе нужно кого-то зафишить. Бывает, когда у целевой организации настроен второй фактор для аутентификации — sms, Google authenticator, Duo. Что делать в таких случаях? Нанимать гопников? Подрезать телефоны у сотрудников? Нет! Оказывается, хитрые хакеры написали софт, способный помочь в этой непростой ситуации.
[Evilginx2](https://github.com/kgretzky/evilginx2) — фреймворк для фишинга, работающий как прокси между жертвой и сайтом, учетки от которого мы хотим получить. Раньше он использовал кастомный nginx, теперь же полностью переписан на Go, включает в себя мини HTTP и DNS серверы, что сильно облегчает установку и развертывание.
Как это работает? Автор софта подробно [описал](https://breakdev.org/evilginx-2-next-generation-of-phishing-2fa-tokens/) на своем сайте, детали по установке и настройке можно найти на [github](https://github.com/kgretzky/evilginx2) странице проекта. Почему же удается обойти второй фактор? Фишка в том, что мы не вмешиваемся в процесс ввода кода из смс / временного пароля / пуша от DUO. Мы тихо ждем, пока пользователь успешно пройдет все шаги аутентификации, ловим его куку, и уже ее используем для входа. Попутно на всякий случай собираем его логин и пароль. В этой же заметке я расскажу о своем опыте и подводных камнях, с которыми столкнулся.
#### Задача
Итак, нам нужно зафишить контору, которая активно использует [Okta](https://en.wikipedia.org/wiki/Okta_(identity_management)) как Single Sign-on. В качестве второго фактора используется [Duo](https://duo.com/) — решение, фишка которого в мобильном клиенте, позволяющем подтверждать второй фактор через обычные пуш-нотификации вместо ввода 35-значных кодов (привет Google Authenticator). Приступим.
#### Шаг первый — регистрируем фишинговый домен
В панели нашего провайдера указываем адрес сервера, на котором будет расположен фишинг. Также регистрируем поддомен вида `okta.<фишинговый домен>.com`.
#### Шаг второй — настраиваем Evilginx
Запускаем Evilginx и через команду `config` вводим необходимые настройки. Указываем основной домен (не поддомен) и его IP.
```
config domain <фишинговый домен>.com
config ip 10.0.0.1
```
В итоге конфиг выглядит так:
Интересен тут параметр `redirect_url` — он указывает куда перенаправлять запрос, когда клиент пришел в корень нашего домена. Зачем это сделано? Если отдавать фишинговую страницу из корня, домен очень быстро вычислят и внесут в списки опасных сайтов, браузеры будут грозно ругаться, и пользователи никогда к нам не попадут. Поэтому мы ее будем отдавать по уникальной ссылке, а корень будет перенаправлять на песню Never Gonna Give You Up.
#### Шаг третий — настраиваем фишинговую страницу
Тут начинается самое интересное. Так как по-факту на нашем сервере мы вообще не хостим никакого контента, а только проксируем запросы, нам нужно "рассказать" Evilginx, какие именно данные мы хотим получить. Этот "рассказ" мы пишем в специальном формате. Документация по нему доступна на [wiki](https://github.com/kgretzky/evilginx2/wiki/Phishlet-File-Format-(2.2.0)) странице проекта. Называются эти описания phishlets. Для некоторых популярных сервисов — facebook, linkedin, amazon они уже написаны и включены в дистрибутив. Нам повезло меньше, из коробки Okta не поддерживается, но добрые люди написали phishlet для [старой](https://github.com/kgretzky/evilginx2/pull/82) версии. Берем напильник и начинаем паять.
Заполняем описание, указываем имя phishlet, авторов, и требуемую версию Evilginx.
```
name: 'okta'
author: '@ml_siegel, updated by @hollow1'
min_ver: '2.2.0'
```
Указываем, какой именно домен собираемся фишить. В нашем случае используется домен вида `<имя целевой компании>.okta.com`.
```
proxy_hosts:
- {phish_sub: '', orig_sub: '<поддомен имя целевой компании>', domain: 'okta.com', session: true, is_landing: true}
```
Параметр `session` указывает на то, что именно этот домен отдает нужные нам куки и туда передаются учетные данные, `is_landing` значит что этот хост будет использоваться для генерации фишинговых URL.
Следующий важный этап — определить все запросы к целевому домену, для того чтобы прокси успешно их переписала на фишинговый домен. Если этого не сделать, пользователь будет отправлять данные не нам, а сразу на оригинальный домен, и никаких учеток мы не поймаем. Переписывать нужно только те запросы, которые непосредственно участвуют в процессе входа пользователя на сайт.
Чтобы четко понимать, что именно требуется для успешной аутентификации, нужно внимательно этот самый процесс изучить. Вооружившись Burp и тестовой учеткой начинаем искать как передается пароль и по каким кукам приложение определяет авторизованного пользователя. Также ищем ответы от сервера, в которых есть ссылки на оригинальный домен.
Находим запрос, в котором передается логин и пароль. Видим что он шлется на оригинальный домен, а нужно чтобы уходил нам.
Вот здесь видно, как оригинальный домен отдает ссылки внутри javascript, их нужно переписать.
Собрав это и еще пару запросов получаем следующие настройки:
```
sub_filters:
- {triggers_on: '<целевой домен>.okta.com', orig_sub: '<целевой домен>', domain: 'okta.com', search: 'https://{hostname}/api', replace: 'https://{hostname}/api', mimes: ['text/html', 'application/json']}
- {triggers_on: 'login.okta.com', orig_sub: 'login', domain: 'okta.com', search: 'https://{hostname}/', replace: 'https://{hostname}/', mimes: ['text/html', 'application/json']}
- {triggers_on: '<целевой домен>.okta.com', orig_sub: '', domain: '<целевой домен>.okta.com', search: 'https\\x3A\\x2F\\x2F{hostname}', replace: 'https\x3A\x2F\x2F{hostname}', mimes: ['text/html', 'application/json', 'application/x-javascript', 'text/javascript']}
- {triggers_on: '<целевой домен>.okta.com', orig_sub: '', domain: '<целевой домен>.okta.com', search: '\\x2Fuser\\x2Fnotifications', replace: 'https\x3A\x2F\x2F<целевой домен>.okta.com\x2Fuser\x2Fnotifications', mimes: ['text/html', 'application/json', 'application/x-javascript', 'text/javascript']}
```
Ключевое слово `{hostname}` как раз используется для замены оригинального домена на фишинговый. Подробнее о синтаксисе этой секции написано [тут](https://github.com/kgretzky/evilginx2/wiki/Phishlet-File-Format-(2.2.0)#sub_filters).
Помните, нам нужны куки, с которыми мы будем авторизоваться на сайте. Путем проб и ошибок выясняем имя куки — `sid`, и дописываем его в настройки:
```
auth_tokens:
- domain: '<целевой домен>.okta.com'
keys: ['sid']
```
Также нам пригодится логин и пароль пользователя, мы уже нашли запрос, в котором они передаются. Как видно в запросе, нужные нам параметры `username` и `password` передаются в json, дописываем:
```
credentials:
username:
key: 'username'
search: '"username":"([^"]*)'
type: 'json'
password:
key: 'password'
search: '"password":"([^"]*)'
type: 'json'
```
Так Evilginx сможет вычленять их из запросов и корректно сохранять.
Осталось немного. Укажем URL страницы логина на целевом домене.
```
landing_path:
- '/login/login.htm'
```
Укажем URL, по которому мы поймем, что пользователь успешно авторизован.
```
auth_urls:
- 'app/UserHome'
```
Вот и все! Конфиг целиком:
```
name: 'okta'
author: '@ml_siegel, updated by @hollow1'
min_ver: '2.2.0'
proxy_hosts:
- {phish_sub: '', orig_sub: '<поддомен имя целевой компании>'', domain: 'okta.com', session: true, is_landing: true}
sub_filters:
sub_filters:
- {triggers_on: '<целевой домен>.okta.com', orig_sub: '<целевой домен>', domain: 'okta.com', search: 'https://{hostname}/api', replace: 'https://{hostname}/api', mimes: ['text/html', 'application/json']}
- {triggers_on: 'login.okta.com', orig_sub: 'login', domain: 'okta.com', search: 'https://{hostname}/', replace: 'https://{hostname}/', mimes: ['text/html', 'application/json']}
- {triggers_on: '<целевой домен>.okta.com', orig_sub: '', domain: '<целевой домен>.okta.com', search: 'https\\x3A\\x2F\\x2F{hostname}', replace: 'https\x3A\x2F\x2F{hostname}', mimes: ['text/html', 'application/json', 'application/x-javascript', 'text/javascript']}
- {triggers_on: '<целевой домен>.okta.com', orig_sub: '', domain: '<целевой домен>.okta.com', search: '\\x2Fuser\\x2Fnotifications', replace: 'https\x3A\x2F\x2F<целевой домен>.okta.com\x2Fuser\x2Fnotifications', mimes: ['text/html', 'application/json', 'application/x-javascript', 'text/javascript']}
- domain: '<целевой подомен>.okta.com'
keys: ['sid']
credentials:
username:
key: 'username'
search: '"username":"([^"]*)'
type: 'json'
password:
key: 'password'
search: '"password":"([^"]*)'
type: 'json'
landing_path:
- '/login/login.htm'
auth_urls:
- 'app/UserHome'
```
Сохраняем его как `okta.yaml` в `/usr/share/evilginx/phishlets`.
#### Шаг четвертый — включаем наш новый фишинг
Запускаем evilginx и пишем команду
```
phishlets hostname okta okta.<наш фишинговый домен>.com
```
Включаем phishlet.
```
phishlets enable okta
```
Под него автоматически создается сертификат от LetsEncrypt.
Проверяем настройки:
Указываем, куда будем редиректить пользователя после успешной авторизации
```
phishlets get-url okta https://<целевой домен>.okta.com/
```
Приложение выдаст ссылку, которую нужно рассылать пользователям, вида `https://<фишинговый домен>.com/login/login.htm?rb=9ffe&ec=<уникальный хеш>`
#### Шаг 4 — ждем улов
Рассылаем письма (технологии рассылки — материал для отдельной статьи) и ждем.
Неокрепший доверчивый пользователь идет по ссылке и авторизуется. Видим мы это так:
Все пойманные учетки складываются в sessions. Выбираем нужную и копируем из нее куки:
Открываем бразуер, подставляем куки и вуаля — мы внутри:
#### Послесловие
Evilginx сильно упрощает создание фишинговых страниц, особенно для 2FA. Также эти страницы удобно хранить и делиться ими с друзьями. Способы защиты — использование девайсов стандарта [U2F](https://fidoalliance.org/specifications/overview/), переход на новые [методы](https://fidoalliance.org/specifications/overview/) аутентификации.
Что думаете об описанном подходе? Как собираете учетки вы? | https://habr.com/ru/post/431156/ | null | ru | null |
# Современный торнадо, часть 2: блокирующие операции
Улучшаем наш [распределённый хостинг картинок](http://habrahabr.ru/post/230607/). В этой части мы поговорим о конфигурировании приложения и подключим защиту от csrf. Затем, на примере создания миниатюр картинок, научимся работать с блокирующими задачами, запускать корутины параллельно и обрабатывать возникающие в них исключения.
### Конфигурирование приложения
Конфигурационные параметры конструктор Application принимает keyword-аргументами. Мы уже сталкивались с этим, передавая `debug=True` вторым параметром в конструктор Application. Однако хардкодить такие настройки не стоит, иначе как запустить скрипт на продакшне, где этот параметр очевидно должен быть `False`? Стандартный для django и других питон-фреймворков приём — хранить общую конфигурацию в файле `settings.py`, в конце которого импортировать `settings_local.py`, перезаписывая специфичные для данного окружения настройки. Конечно, вы вполне можете использовать этот трюк, однако в [tornado](http://tornado.readthedocs.org/) есть возможность изменять конкретные настройки с помощью параметров командной строки. Давайте посмотрим как это реализуется:
```
from tornado.options import define, options
define('port', default=8000, help='run on the given port', type=int)
define('db_uri', default='localhost', help='mongodb uri')
define('db_name', default='habr_tornado', help='name of database')
define('debug', default=True, help='debug mode', type=bool)
options.parse_command_line()
db = motor.MotorClient(options.db_uri)[options.db_name]
```
C помощью `define` мы определяем параметры в синтаксисе [optparse](https://docs.python.org/3.5/library/optparse.html). А затем в нужном месте получаем их с помощью options. Вызывая `options.parse_command_line()` мы перезаписываем дефолтные значения параметров данными из командной строки. То есть на продакшне нам теперь достаточно запустить приложение с параметром `--debug=False`. А запуск с параметром `--help` покажет нам все возможные параметры:
```
$python3 app.py --help
Usage: app.py [OPTIONS]
Options:
--db_name name of database (default habr_tornado)
--db_uri mongodb uri (default localhost)
--debug debug mode (default True)
--help show this help information
--port run on the given port (default 8000)
/home/imbolc/.pyenv/versions/3.4.0/lib/python3.4/site-packages/tornado/log.py options:
--log_file_max_size max size of log files before rollover
(default 100000000)
--log_file_num_backups number of log files to keep (default 10)
--log_file_prefix=PATH Path prefix for log files. Note that if you
are running multiple tornado processes,
log_file_prefix must be different for each
of them (e.g. include the port number)
--log_to_stderr Send log output to stderr (colorized if
possible). By default use stderr if
--log_file_prefix is not set and no other
logging is configured.
--logging=debug|info|warning|error|none
Set the Python log level. If 'none', tornado
won't touch the logging configuration.
(default info)
```
Как видите торнадо автоматически добавил параметры логирования.
### CSRF
Теперь добавим к настройкам приложения `xsrf_cookies=True`. Попробовав загрузить новую картинку, мы увидим ошибку: `HTTP 403: Forbidden ('\_xsrf' argument missing from POST)`. Это сработала защита от [csrf](http://en.wikipedia.org/wiki/Cross-site_request_forgery). Для восстановления работы приложения, достаточно в форму загрузки добавить `{% module xsrf_form_html() %}`, в хтмл-коде страницы это превратится во что-то типа: .
### Миниатюры изображений
При отображении миниатюр в списке последних картинок мы для простоты использовали полные изображения. Настало время поправить этот момент. Нам понадобится [pillow](https://pillow.readthedocs.org/en/latest/) (это современный форк PIL — известной библиотеки для работы с изображениями):
```
pip3 install pillow
```
Однако, торнадо однопоточен и такая ресурсоёмкая операция как обработка изображений, сведёт на нет все наши пляски с асинхронностью. Самое простое решение — вынести эту задачу в отдельный тред:
```
import os
import io
from concurrent.futures import ThreadPoolExecutor
from PIL import Image
class UploadHandler(web.RequestHandler):
executor = ThreadPoolExecutor(max_workers=os.cpu_count())
@gen.coroutine
def post(self):
file = self.request.files['file'][0]
try:
thumbnail = yield self.make_thumbnail(file.body)
except OSError:
raise web.HTTPError(400, 'Cannot identify image file')
orig_id, thumb_id = yield [
gridfs.put(file.body, content_type=file.content_type),
gridfs.put(thumbnail, content_type='image/png')]
yield db.imgs.save({'orig': orig_id, 'thumb': thumb_id})
self.redirect('')
@run_on_executor
def make_thumbnail(self, content):
im = Image.open(io.BytesIO(content))
im.convert('RGB')
im.thumbnail((128, 128), Image.ANTIALIAS)
with io.BytesIO() as output:
im.save(output, 'PNG')
return output.getvalue()
```
Сначала мы создаём пулл воркеров с ограничением их количества количеством ядер cpu (это оптимально для процессоро-ёмких задач типа обработки изображений). И если одновременно будет загружено больше изображений остальные будут ждать своей очереди. Затем мы асинхронно создаём миниатюру, вызывая наш метод `make_thumbnail`, обёрнутый декоратором [run\_on\_executor](http://tornado.readthedocs.org/en/stable/concurrent.html#tornado.concurrent.run_on_executor), что вызовет выполнение задачи в одном из тредов executor-а.
Обратите внимание, как красиво мы перехватываем исключение `OSError` которое бросает pillow если не может распознать формат изображения. Нам не требуется явно передавать ошибку в ответе как это делается в случае колбэчной асинхронности (например в node.js). Просто, работаем с исключениями в синхронном стиле.
Далее мы сохраняем оригинальное изображение и миниатюру в [gridfs](http://docs.mongodb.org/manual/core/gridfs/). Обратите внимание, что вместо последовательного вызова:
```
orig_id = yield gridfs.put(file.body, content_type=file.content_type)
thumb_id = yield gridfs.put(thumbnail, content_type='image/png')
```
Мы используем параллельный `orig_id, thumb_id = yield [ ... ]`. То есть файлы сохраняются одновременно. Такой параллельный вызов корутин имеет смысл при любых не зависящих друг от друга операциях. Например, мы могли бы объединить создание миниатюры с сохранением оригинала, но совместить создание и сохранение миниатюры не удастся так как вторая операция зависит от результатов первой.
В завершение мы сохраняем информацию об изображении в коллекцию `imgs`. Эта коллекция нужна, чтобы связать миниатюру и оригинал изображения. Так же в дальнейшем там можно хранить любую информацию об изображении: автора, права доступа и т.п. С появлением этой коллекции соответственно изменятся и методы отображения списка и отдельного изображения:
```
class UploadHandler(web.RequestHandler):
...
@gen.coroutine
def get(self):
imgs = yield db.imgs.find().sort('_id', -1).to_list(20)
self.render('upload.html', imgs=imgs)
class ShowImageHandler(web.RequestHandler):
@gen.coroutine
def get(self, img_id, size):
try:
img_id = bson.objectid.ObjectId(img_id)
except bson.errors.InvalidId:
raise web.HTTPError(404, 'Bad ObjectId')
img = yield db.imgs.find_one(img_id)
if not img:
raise web.HTTPError(404, 'Image not found')
gridout = yield gridfs.get(img[size])
self.set_header('Content-Type', gridout.content_type)
self.set_header('Content-Length', gridout.length)
yield gridout.stream_to_handler(self)
```
Как видите, `ShowImageHandler.get` получает теперь дополнительный параметр `size` — уточняющий хотим ли мы получить миниатюру изображения или оригинал. Соответственно изменилась и регулярка url:
```
web.url(r'/imgs/([\w\d]+)/(orig|thumb)', ShowImageHandler,
name='show_image'),
```
И восстановление этих url в шаблоне:
```
{% for img in imgs %}
[ }})]({{ reverse_url('show_image', img['_id'], 'orig') }})
{% end %}
```
### Заключение
На сегодня всё, код этой и [предыдущей](http://habrahabr.ru/post/230607/) части доступен на [github](https://github.com/imbolc/habr-modern-tornado). | https://habr.com/ru/post/231201/ | null | ru | null |
# Использование Global Illumination в собственных шейдерах в Unity 5
Привет, Хабр! Unity 5 предоставляет нам из коробки систему глобального освещения (Global Illumination, GI), которая позволяет в реальном времени получать действительно очень приятную картинку, что разработчики продемонстрировали в своем нашумевшем ролике [The Blacksmith](https://unity3d.com/ru/pages/the-blacksmith). Наряду с системой глобального освещения универсальный материал Standard перевел в разряд устаревших все прежние материалы. Несмотря на крутость стандартного материала (а он, ни много ни мало, основан на физической модели), я задался вопросом, а можно ли подключить систему глобального освещения к собственному поверхностному шейдеру. Что из этого получилось, а также с чем мне пришлось столкнуться в процессе, читайте под катом.
#### Что хорошего в системе глобального освещения Unity 5?
В системе глобального освещения в Unity 5 меня в первую очередь привлекла не симуляция ambient-освещения, а встроенные отражения. Разработчики добавили в движок новый механизм, который получил название [Reflection Probes](http://docs.unity3d.com/ru/current/Manual/class-ReflectionProbe.html). Принцип его работы достаточно прост: на сцене мы размещаем в нужных местах специальные маркеры (зонды), которые сохраняют отражения вокруг себя в кубических текстурах. При перемещении между маркерами выбирается пара наиболее значимых, и отражения, полученные от обоих, смешиваются. Отражения могут вычисляться в реальном времени, в момент активации маркера или вообще управляться скриптом, где можно реализовать, например, таймеры. Подобные системы часто реализуют в играх, где постоянно необходимы отражения, в частности, для имитации материала автомобильной краски. Согласитесь, очень не хочется изобретать велосипед, когда в движке уже все сделано.
Симуляция вторичного освещения также очень круто может увеличить реализм вашего рендеринга. В реальном мире многие материалы переотражают падающий на них свет и сами становятся источниками света. Чтобы рассчитать такое вторичное (indirect) освещение в реальном времени, современных вычислительных мощностей не хватает, однако его можно предрассчитать для статических объектов и изредка пересчитывать для динамических, что и реализовано в Unity 5. Рассчитанные данные упаковываются в текстуры, которые затем используются уже при рендеринге в реальном времени. Эти текстуры называются картами освещенности или лайтмапами.
Unity 5 предоставляет несколько механизмов, влияющих на формирование глобального освещения:
* Присвоение источнику света типа Baked или Mixed. Такой источник света будет работать через лайтмап и не влиять на динамические объекты (тип Baked) или работать для динамических объектов как полноценный источник света (тип Mixed).
* Создание маркеров освещенности ([Light Probes](http://docs.unity3d.com/Manual/LightProbes.html)). Маркеры освещенности представляют собой трехмерный граф, в узлах которого сохраняется уровень освещенности, создаваемый различными источниками света. При рендеринге в реальном времени для расчета освещения используются данные интерполированные по сетке графа.
* Технология [Directional Lightmapping](http://docs.unity3d.com/Manual/LightmappingDirectional.html). При расчете indirect-освещения можно считать все поверхности идеально плоскими, т. е. переотражающими свет одинаково во всех направлениях, а можно учитывать преимущественное направление переотражения, используя для этого данные из карты нормалей. В этом и заключается суть данной технологии. Поддерживается также режим Directional Specular, который позволяет учитывать блики, что позволяет создавать полноценное вторичное освещение.
Все это имеет множество параметров, позволяющих учесть баланс производительность-качество, что еще больше подняло технологию в моих глазах. Однако, исследуя новые возможности движка, я работал на тестовой сцене с материалом Standard, что меня, в конечном счете, не устраивало, я хотел подключить собственный поверхностный шейдер к системе глобального освещения.
#### Создание поверхностного шейдера
Здесь меня ждал первый сюрприз: в документации к движку нет информации по тому, как правильно подключать собственный поверхностный шейдер к системе GI. Вместо этого документация пестрит заметками вида «переходим все на материал Standard» и «почему ваши материалы хуже, чем Standard». К счастью, исходники всех встроенных шейдеров находятся в открытом доступе и лежат либо в папке CGIncludes, либо их можно скачать с официального сайта. По результатам исследования исходников выяснилось следующее:
* Для того чтобы ваш шейдер взаимодействовал с системой GI, необходимо переопределить функцию со следующей сигнатурой:
```
inline void LightingYourModelName_GI(YourSurfaceOutput s, UnityGIInput data, inout UnityGI gi)
```
где *YourModelName* — имя вашей модели освещения, *YourSurfaceOutput* — имя вашей структуры данных с параметрами поверхности, *UnityGIInput* — входные данные для расчета глобального освещения, *UnityGI* — результат расчета глобального освещения.
Внутри этой функции, понятно, необходимо рассчитать глобальное освещение, для чего служит встроенная функция
```
inline UnityGI UnityGlobalIllumination (UnityGIInput data, half occlusion, half oneMinusRoughness, half3 normalWorld, bool reflections)
```
Данная функция определена в файле CGIncludes/UnityGlobalIllumination.cginc. Параметр *occlusion* отвечает за дополнительное затенение. В него можно, например, передать результаты работы какой-либо вариации алгоритма [Ambient Occlusion](https://ru.wikipedia.org/wiki/Ambient_occlusion). Параметр *oneMinusRoughness* определяет нечто вроде глянцевости материала. Данный параметр используется при расчете отражений, чем меньше глянцевость, тем менее четкие отражения мы будем получать. Булевый параметр *reflections* позволяет выключить расчет отражений, предназначение остальных параметров очевидно.
В итоге у меня получилась следующая функция:
```
inline void LightingUniversal_GI(SurfaceOutputUniversal s, UnityGIInput data, inout UnityGI gi)
{
gi = UnityGlobalIllumination(data, 1.0 /* occlusion */, 1.0 - s.Roughness, normalize(s.Normal));
}
```
* Функция, содержащая модель освещения, несколько изменилась по сравнению с предыдущими версиями Unity. Теперь она имеет сигнатуру
```
inline fixed4 LightingYourModelName(YourSurfaceOutput s, half3 viewDir, UnityGI gi)
```
Параметры *atten* и *lightDir* (кому-то знакомые по предыдущим версиям движка) уступили место структуре UnityGI. В этой структуре могут содержаться до 3 источников света (*light*, *light2* и *light3*), а также данные о вторичном освещении в параметре *indirect*. Вторичное освещение разбивается на две компоненты: *diffuse* — рассеянный свет от вторичных источников света и *specular* — бликовая компонента (именно через нее передаются отражения). Чтобы лучше понять, как все эти данные применять рассмотрим следующий псевдокод:
```
inline fixed4 LightingYourModelName(YourSurfaceOutput s, half3 viewDir, UnityGI gi)
{
// Рассчитать освещение от основного источника счета gi.light
#if defined(DIRLIGHTMAP_SEPARATE)
#ifdef LIGHTMAP_ON
// В случае использования статического лайтмапа параметры источника света будут в gi.light2
#endif
#ifdef DYNAMICLIGHTMAP_ON
// В случае использования динамического лайтмапа параметры источника света будут в gi.light3
#endif
#endif
#ifdef UNITY_LIGHT_FUNCTION_APPLY_INDIRECT
// Здесь добавляется вклад indirect-освещения
#endif
}
```
Нетрудно видеть, что функция, описывающая модель освещения, содержит несколько блоков под директивами условной компиляции. Шейдеры в Unity построены в соответствии с популярной парадигмой, называемой über-шейдеры. Согласно этой парадигме пишется наиболее общий шейдер (в идеале один единственный), блоки кода в котором оборачиваются условной компиляцией. Шейдер компилируется согласно потребностям материала. В итоге, один исходник — множество скомпилированных вариантов. Так вот, возвращаясь к нашей функции, источник света *gi.light* должен применяться всегда, так как содержит параметры основного источника света для данного прохода шейдера. Остальные два источника света могут быть использованы только в режиме Directional Lightmapping со включенным бликовым освещением (Directional Specular). Источник света *gi.light2* будет активен только в случае использования статического лайтмапа, а источник *gi.light3* будет работать в условиях динамического лайтмэппинга. В конце функции под директивой *UNITY\_LIGHT\_FUNCTION\_APPLY\_INDIRECT* применяется вторичное освещение.
Также хочу отметить любопытную историю, которая произошла с параметром *viewDir*. Как некоторым наверняка известно, в функции, описывающей модель освещения, параметр *viewDir* можно опускать, если он вам не нужен. Это позволяет шейдерному кодогенератору формировать чуть более оптимальный код. Однако, если вы планируете использовать отражения из системы GI, параметр *viewDir* в сигнатуре функции придется оставить, даже если он вам не нужен. Дело в том, что встроенная функция *UnityGlobalIllumination* использует направление взгляда для расчета вектора отражения. Если кодогенератор не обнаружит в сигнатуре функции параметра *viewDir*, он оптимизирует код, и отражения перестанут работать.
В основу своего поверхностного шейдера я положил модель освещения Кука-Торранса, о которой вы можете прочитать [здесь](http://www.gamedev.ru/code/articles/Cook-Torrance) или [здесь](http://habrahabr.ru/company/mailru/blog/248873/). Под спойлером вы найдете полный код получившегося шейдера. Теперь посмотрим на то, что у нас получилось.
**Полный код поверхностного шейдера**
```
Shader "ShadersLabs/Universal"
{
Properties
{
_MainColor("Color", Color) = (1,1,1,1)
_MainTex("Albedo", 2D) = "white" {}
_NormalMap("Normal", 2D) = "bump" {}
_EmissionMap("Emission (RGB), Specular (A)", 2D) = "black" {}
_Roughness("Roughness", Range(0,1)) = 0.1
_ReflectionPower("Reflection Power", Range(0.01, 5)) = 3
_Metallic ("Metallic", Range(0,1)) = 0.0
}
SubShader
{
Tags { "RenderType"="Opaque" }
LOD 200
CGPROGRAM
#pragma surface surf Universal fullforwardshadows exclude_path:prepass exclude_path:deferred
#pragma target 3.0
struct Input
{
half2 uv_MainTex;
};
struct SurfaceOutputUniversal
{
fixed3 Albedo;
fixed3 Normal;
fixed3 Emission;
fixed Specular;
fixed Metallic;
fixed Roughness;
fixed ReflectionPower;
fixed Alpha;
};
sampler2D _MainTex;
sampler2D _NormalMap;
sampler2D _SpecularMap;
sampler2D _EmissionMap;
fixed4 _MainColor;
fixed _Roughness;
fixed _ReflectionPower;
fixed _Metallic;
inline fixed3 CalculateCookTorrance(SurfaceOutputUniversal s, half3 n, fixed vdn, half3 viewDir, UnityLight light)
{
half3 h = normalize(light.dir + viewDir);
fixed ndl = saturate(dot(n, light.dir));
fixed ndh = saturate(dot(n, h));
fixed vdh = saturate(dot(viewDir, h));
fixed ndh2 = ndh * ndh;
fixed sp2 = max(s.Roughness * s.Roughness, 0.001);
fixed G = min(1.0, 2.0 * ndh * min(vdn, ndl) / vdh);
fixed D = exp((ndh2 - 1.0)/(sp2 * ndh2)) / (4.0 * sp2 * ndh2 * ndh2);
fixed F = 0.5 + 0.5 * pow(1.0 - vdh, s.ReflectionPower);
fixed spec = saturate(G * D * F / (vdn * ndl));
return light.color * (s.Albedo * ndl + fixed3(s.Specular, s.Specular, s.Specular) * spec);
}
inline fixed3 CalculateIndirectSpecular(SurfaceOutputUniversal s, fixed vdn, half3 indirectSpec)
{
fixed rim = saturate(pow(1.0 - vdn, s.ReflectionPower));
return indirectSpec * rim * s.Metallic;
}
inline fixed4 LightingUniversal(SurfaceOutputUniversal s, half3 viewDir, UnityGI gi)
{
half3 n = normalize(s.Normal);
fixed vdn = saturate(dot(viewDir, n));
fixed4 c = fixed4(CalculateCookTorrance(s, n, vdn, viewDir, gi.light), s.Alpha);
#if defined(DIRLIGHTMAP_SEPARATE)
#ifdef LIGHTMAP_ON
c.rgb += CalculateCookTorrance(s, n, vdn, viewDir, gi.light2);
#endif
#ifdef DYNAMICLIGHTMAP_ON
c.rgb += CalculateCookTorrance(s, n, vdn, viewDir, gi.light3);
#endif
#endif
#ifdef UNITY_LIGHT_FUNCTION_APPLY_INDIRECT
c.rgb += (s.Albedo * gi.indirect.diffuse + CalculateIndirectSpecular(s, vdn, gi.indirect.specular));
#endif
return c;
}
inline void LightingUniversal_GI(SurfaceOutputUniversal s, UnityGIInput data, inout UnityGI gi)
{
gi = UnityGlobalIllumination(data, 1.0 /* occlusion */, 1.0 - s.Roughness, normalize(s.Normal));
}
void surf(Input IN, inout SurfaceOutputUniversal o)
{
fixed4 c = _MainColor * tex2D(_MainTex, IN.uv_MainTex);
fixed4 e = tex2D(_EmissionMap, IN.uv_MainTex);
o.Albedo = c.rgb;
o.Normal = normalize(UnpackNormal(tex2D(_NormalMap, IN.uv_MainTex)));
o.Specular = e.a;
o.Emission = e.rgb;
o.Metallic = _Metallic;
o.Roughness = _Roughness;
o.ReflectionPower = _ReflectionPower;
o.Alpha = c.a;
}
ENDCG
}
FallBack "Diffuse"
}
```
#### Результаты
На сцену были помещены 3 шарика, плоскость и 2 источника света (направленный, имитирующий Солнце, и точечный типа Mixed прямо перед шариками). Также был добавлен один Reflection Probe для создания отражений.
В результате мы получаем следующую картинку (слева глобальное освещение выключено, справа — включено).
На изображении ниже представлен вклад отражений и переотраженного света, которые формируются системой глобального освещения.
Если заменить режим лайтмэппинга Directional Specular в пользу режима Directional, картинка станет поскучней, однако это позволит несколько выиграть по производительности. Кроме того, режим Directional Specular не поддерживается на старых версиях графических API, например, Open GL ES 2.0.
#### Ложка дёгтя
Полученные результаты, в целом, меня удовлетворили. Однако, оставался последний нерешенный вопрос. Все, что я реализовал, не поддерживало режим отложенного освещения ([deferred shading](http://www.gamedev.ru/terms/DeferredShading)). Unity 5 предоставляет такой режим освещения из коробки, и, для полноты картины, его было бы круто поддержать.
Здесь меня ждало самое большое разочарование. В текущей версии движка (я использовал 5.1.3) можно переопределить функцию для записи данных в G-буфер (*LightingYourModelName\_Deferred*), а вот функцию, которая декодирует G-буферы, переопределить нельзя. Точнее, существует способ, требующий определенных дополнительных приседаний. Документация к движку по этому поводу говорит следующее:
> «The only lighting model available is Standard. If a different model is wanted you can modify the lighting pass shader, by placing the modified version of the Internal-DeferredShading.shader file from the Built-in shaders into a folder named “Resources” in your “Assets” folder.»
Таким образом, единственный теоретический способ добиться желаемого — модифицировать внутренний шейдер и подложить его в определенное место в проекте. Никаких иных более детальных указаний документация не предоставляет. К слову, простое копирование в нужное место результата мне не принесло, движок по-прежнему использовал внутренний исходный шейдер.
Правильное решение мне подсказал г-н [marked-one](https://habrahabr.ru/users/marked-one/), за что ему большая благодарность. Для того чтобы заставить Unity использовать ваш собственный шейдер для декодирования G-буферов, необходимо зайти в *Edit -> Project Settings -> Graphics* и для *Built-in shader settings -> Deferred* в списке выбрать Custom Shader, затем выбрать ваш собственный шейдер. После этого Unity насчет использовать выставленный шейдер для всего движка, включая редактор.
#### Выводы
Что я вынес для себя из этой истории, разработчики Unity создали очень неплохую систему глобального освещения. Ее можно и нужно использовать, если вы не применяете в своем проекте отложенное освещение (а если применяете, то готовьтесь дорабатывать внутренние шейдеры Unity). Как альтернативу можно рассмотреть полный переход на материал Standard, на который разработчики Unity, судя по всему, делают большую ставку. Этот материал работает во всех режимах, однако, переводить свой проект на него я бы не стал. Ценой стала бы потеря контроля как над визуальным образом игры, так и над ее производительностью. Выводы для себя вы сделаете сами, я же, со своей стороны, надеюсь, что вам доставило удовольствие прочтение данного поста. Любите качественный рендеринг, до новых встреч! | https://habr.com/ru/post/251045/ | null | ru | null |
# Разделяй и властвуй. Модульное приложение из монолита на Objective-C и Swift
Привет, Хабр! Меня зовут Василий Козлов, я iOS-техлид в Delivery Club, и застал проект в его монолитном виде. Признаюсь, что приложил руку к тому, борьбе с чем посвящена эта статья, но раскаялся и трансформировал своё сознание вместе с проектом.
Я хочу рассказать, как разбивал существующий проект на Objective-C и Swift на отдельные модули — framework’и. [Согласно Apple](https://developer.apple.com/library/archive/technotes/tn2435/_index.html), framework — это директория определенной структуры.
Изначально мы поставили цель: обособить код, реализующий функцию чата для поддержки пользователей, и уменьшить длительность сборки. Это привело к полезным последствиям, которым сложно следовать, не имея привычки и существуя в монолитном мире одного проекта.
Неожиданно пресловутые принципы [SOLID](https://ru.wikipedia.org/wiki/SOLID_(%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)) начали обретать очертания, а главное — сама постановка задачи вынуждала организовывать код в соответствии с ними. Вынося какую-то сущность в отдельный модуль, вы автоматически сталкиваетесь со всеми её зависимостями, которые не должны находиться в этом модуле, а также дублироваться в главном проекте приложения. Поэтому назрел вопрос об организации дополнительного модуля с общей функциональностью. Это ли не принцип единой ответственности, когда одна сущность должна иметь одно предназначение?
Сложность разделения на модули проекта с двумя языками и большим наследием может отпугнуть при первом взгляде, что со мной и произошло, но интерес к новой задаче одержал победу.
В предварительно найденных статьях [авторы обещали](https://medium.com/kinandcartacreated/modular-ios-strangling-the-monolith-4a6843a28992) безоблачное будущее при выполнении простых и четких шагов, характерных для нового проекта. Но когда я перенёс первый базовый класс в модуль для общего кода, выявилось столько неочевидных зависимостей, столько строчек кода покрылось красным в Xcode, что продолжать дальше не хотелось.
Проект содержал много legacy-кода, перекрестных зависимостей от классов на Objective-C и Swift, разных target’ов в терминах iOS-разработки, внушительный список CocoaPods. Любой шаг в сторону от этого монолита приводил к тому, что проект переставал собираться в Xcode, обнаруживая порой ошибки в самых неожиданных местах.
Поэтому я решил записать последовательность предпринятых мною действий, чтобы облегчить жизнь владельцам таких проектов.
Первые шаги
-----------
Они очевидны, о них написано много [статей](https://medium.com/kinandcartacreated/modular-ios-splitting-a-workspace-into-modules-331293f1090). Apple постаралась сделать их максимально удобными.
**1.** Создаем первый модуль: File → New Project → Cocoa Touch Framework
**2.** Добавляем модуль в workspace проекта
**3.** Создаем зависимость основного проекта от модуля, указав последний в разделе Embedded Binaries. Если в проекте несколько target’ов, то модуль надо будет включить в раздел Embedded Binaries каждого зависящего от него target’а.
От себя добавлю только один комментарий: не спешите.
Знаете ли вы, что будет размещено в этом модуле, по какому признаку будут разделены модули? В моём варианте это должен был быть `UIViewController` для чата с таблицей и ячейками. К модулю должен был быть привязан Cocoapods с чатом. Но вышло всё немного по-другому. Реализацию чата мне пришлось отложить, потому что и `UIViewController`, и его presenter, и даже ячейка основывались на базовых классах и протоколах, о которых новый модуль ничего не знал.
Как выделить модуль? Наиболее логичный подход — по «фичам» ([features](https://youtu.be/XG5Q5lh24D4?t=7416)), то есть по какой-то пользовательской задаче. Например, чат с техподдержкой, экраны регистрации/авторизации, bottom sheet с настройками основного экрана. Кроме этого, скорее всего, понадобится какая-то базовая функциональность, которая представляет из себя не feature, а лишь набор UI-элементов, базовых классов и т.д. Эту функциональность следует вынести в общий модуль, аналогичный знаменитому файлу [Utils](http://www.google.ru/search?q=+utils+file). Не бойтесь раздробить и этот модуль. Чем меньше кубики, тем проще их вписать в основную постройку. Мне кажется, так можно сформулировать еще один из принципов [SOLID](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B8%D0%BD%D1%86%D0%B8%D0%BF_%D1%80%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D0%B8%D0%BD%D1%82%D0%B5%D1%80%D1%84%D0%B5%D0%B9%D1%81%D0%B0).
Есть [готовые советы](https://github.com/tuist/microfeatures-guidelines#types-of-%C2%B5features-) по разделению на модули, которыми я не воспользовался, потому и сломал столько копий, и даже решил рассказать о наболевшем. Однако такой подход — сначала действовать, потом думать — как раз и открыл мне глаза на ужас зависимого кода в монолитном проекте. Когда вы в начале пути, вам сложно объять всё количество изменений, которые потребуются для устранения зависимостей.
Поэтому просто переместите класс из одного модуля в другой, посмотрите, что «покраснело» в Xcode, и постарайтесь разобраться с зависимостями. Xcode 10 хитёр: при перемещении ссылок на файлы из одного модуля в другой он оставляет файлы на прежнем месте. Потому следующий шаг будет таким…
**4.** Перемещайте файлы в файловом менеджере, удаляйте старые ссылки в Xcode и заново добавляйте файлы в новый модуль. Если делать это по классу за раз, будет легче не запутаться в зависимостях.
Чтобы сделать все обособленные сущности доступными извне модуля, придётся принять во внимание особенности Swift и Objective-C.
**5.** В Swift все классы, перечисления и протоколы должны быть помечены модификатором доступа `public`, тогда к ним можно будет получить доступ снаружи модуля. Если в отдельный framework перемещается базовый класс, его следует пометить модификатором `open`, иначе не получится создать от него класс-потомок.
Сразу следует вспомнить (или впервые узнать), какие есть уровни доступа в Swift, и получить profit!
При изменении уровня доступа у перенесённого класса Xcode потребует изменить уровень доступа у всех переопределённых методов на идентичный.
Затем необходимо добавить импорт нового framework’а в Swift-файл, где используется выделенная функциональность, наряду с каким-нибудь UIKit. После этого ошибок в Xcode должно стать меньше.
```
import UIKit
import FeatureOne
import FeatureTwo
class ViewController: UIViewController {
//..
}
```
С Objective-C последовательность действий немного сложнее. Кроме того, использование bridging header’а для импорта классов Objective-C в Swift не поддерживается во framework’ах.
Поэтому поле Objective-C Bridging Header должно быть пустым в настройках framework’а.
Из сложившейся ситуации есть выход, и почему это так — тема отдельного исследования.
**6.** У каждого framework’а есть собственный заголовочный файл — [umbrella header](https://developer.apple.com/documentation/swift/imported_c_and_objective-c_apis/importing_objective-c_into_swift), через который будут смотреть во внешний мир все публичные интерфейсы Objective-C.
Если в этом umbrella header указать импорт всех прочих заголовочных файлов, то они будут доступны в Swift.
```
import UIKit
import FeatureOne
import FeatureTwo
class ViewController: UIViewController {
var vc: Obj2ViewController?
override func viewDidLoad() {
super.viewDidLoad()
// Do any additional setup after loading the view, typically from a nib.
}
```
В Objective-C, чтобы получить доступ к классам снаружи модуля, нужно поиграться с его настройками: сделать заголовочные файлы публичными.
**7.** Когда все файлы поодиночке перенесены в отдельный модуль, нужно не забыть о Cocoapods. Файл Podfile требует реорганизации, если какая-то функциональность окажется в отдельном framework’е. У меня так и было: pod с графическими индикаторами надлежало вынести в общий framework, а чат — новый pod — был включён в свой собственный отдельный framework.
Необходимо явно указать, что проект теперь не просто проект, а рабочее пространство с подпроектами:
```
workspace 'myFrameworkTest'
```
Общие для framework’ов зависимости следует вынести в отдельные переменные, например, `networkPods` и `uiPods`:
```
def networkPods
pod 'Alamofire'
end
def uiPods
pod 'GoogleMaps'
end
```
Тогда зависимости основного проекта будут описаны следующим образом:
```
target 'myFrameworkTest' do
project 'myFrameworkTest'
networkPods
uiPods
target 'myFrameworkTestTests' do
end
end
```
Зависимости framework’а с чатом — таким образом:
```
target 'FeatureOne' do
project 'FeatureOne/FeatureOne'
uiPods
pod 'ChatThatMustNotBeNamed'
end
```
Подводные камни
---------------
Наверное, на этом можно было бы закончить, но в дальнейшем я обнаружил несколько неявных проблем, о которых также хочется упомянуть.
Все общие зависимости вынесены в один отдельный framework, чат — в другой, код стал немного чище, проект собирается, но при запуске падает.
Первая проблема скрывалась в реализации чата. На просторах сети проблема встречается и в других pod’ах, достаточно *загуглить* «**Library not loaded: Reason: image not found**». Именно с таким сообщением происходило падение.
Более элегантного решения я не нашёл и был вынужден продублировать подключение pod’а с чатом в основном приложении:
```
target 'myFrameworkTest' do
project 'myFrameworkTest'
pod 'ChatThatMustNotBeNamed'
networkPods
uiPods
target 'myFrameworkTestTests' do
end
end
```
Таким образом Cocoapods позволяет приложению видеть динамически подключенную библиотеку при запуске и при компиляции проекта.
Другая проблема заключалась в ресурсах, про которые я благополучно забыл и нигде не встречал упоминания о том, что этот аспект надо держать в уме. Приложение падало при попытке зарегистрировать xib-файл ячейки: **«Could not load NIB in bundle»**.
Конструктор `init(nibName:bundle:)` класса `UINib` по умолчанию ищет ресурс в модуле главного приложения. Естественно, об этом ничего не знаешь, когда разработка ведется в монолитном проекте.
Решение — указывать bundle, в котором определен класс ресурса, либо позволить компилятору сделать это самому, используя конструктор `init(for:)` класса `Bundle`. Ну и, конечно, впредь не забывать о том, что ресурсы теперь могут быть общими для всех модулей или специфичными для одного модуля.
Если в модуле используются xib’ы, то Xcode будет, как обычно, предлагать для кнопок и `UIImageView` выбирать графические ресурсы из всего проекта, но в run time все расположенные в других модулях ресурсы окажутся не загруженными. Я загружал изображения в коде, используя конструктор `init(named:in:compatibleWith:)` класса `UIImage`, где вторым параметром идёт `Bundle`, в котором расположен файл изображения.
Ячейки в `UITableView` и `UICollectionView` теперь также должны регистрироваться подобным образом. Причем надо помнить, что Swift-классы в строковом представлении включают в себя ещё и имя модуля, а метод `NSClassFromString()` из Objective-C возвращает `nil`, поэтому рекомендую регистрировать ячейки, указывая не строку, а класс. Для `UITableView` можно воспользоваться таким вспомогательным методом:
```
@objc public extension UITableView {
func registerClass(_ classType: AnyClass) {
let bundle = Bundle(for: classType)
let name = String(describing: classType)
register(UINib(nibName: name, bundle: bundle), forCellReuseIdentifier: name)
}
}
```
Выводы
------
Теперь можно не переживать, если в одном pull request окажутся изменения в структуре проекта, сделанные в разных модулях, потому что у каждого модуля свой xcodeproj-файл. Можно распределять работу так, чтобы не приходилось тратить несколько часов на сведение файла проекта воедино. Полезно иметь модульную архитектуру в больших и распределенных командах. Как следствие, должна увеличиться скорость разработки, но верно и обратное. На свой самый первый модуль я потратил гораздо больше времени, чем если бы создавал чат внутри монолита.
Из очевидных плюсов, на которые также указывает [Apple](https://developer.apple.com/library/archive/technotes/tn2435/_index.html), — возможность снова использовать код. Если в приложении имеются различные target’ы (app extensions), то это самый доступный подход. Возможно, чат не самый лучший вариант для примера. Следовало начать с вынесения сетевого слоя, но давайте будем честными сами с собой, это очень длинная и опасная дорога, которую лучше разбить на небольшие отрезки. А так как за последние пару лет это было внедрение второго сервиса для организации технической поддержки, хотелось внедрить его не внедряя. Где гарантии, что скоро не появится третий?
Один неочевидный эффект при разработке модуля — более продуманные, чистые интерфейсы. Разработчику приходится проектировать классы так, чтобы определенные свойства и методы были доступны извне. Поневоле приходится задумываться, что сокрыть и как сделать модуль таким, чтобы его можно было с легкостью использовать снова. | https://habr.com/ru/post/514614/ | null | ru | null |
# TDD для хранимых процедур Oracle
На одном из наших недавних проектов мы столкнулись с серьёзной проблемой. Веб-приложение, которое мы разрабатывали, должно было использовать внутренюю базу данных финансовой организации. Из соображений безопасности, доступ был очень сильно ограничен: любые изменения необходимо было делать при помощи хранимых процедур, а читать данные — только при помощи представлений. Таким образом, приложение должно было выполнять сложные манипуляции данными, не имея никакого представления об их структуре. Основной загвоздкой для нас было то, что наше приложение попадало в зависимость от больших и сложных процедур, для которых не существовало автоматизированных тестов.
Погуглив немного, мы обнаружили, что в штатном инструментарии Oracle SQL Developer [1] есть функционал для создания автоматизированных тестов. Мы тут же приступили к его изучению. И хотя тесты для самой сложной процедуры пришлось создавать уже после её написания, этот инструментарий всё же помог нам устранить несколько ошибок, а также существенно облегчил процесс расширения функционала и рефакторинга. Ниже я приведу пример использования TDD для построения хранимых процедур, а также поделюсь опытом в работе с инструментарием.
#### Пример использования
Допустим, у заказчика имеется существующее приложение, которое позволяет его клиентам выполнять отправку СМС-сообщений. Ещё одна команда разрабатывает новое приложение, которое должно будет работать параллельно с существующим, поэтому было бы хорошо иметь общее место для бизнес-логики.
#### Структура данных
Приложение использует следующую структуру данных:
```
CREATE TABLE CLIENTS(
ID NUMBER GENERATED BY DEFAULT AS IDENTITY NOT NULL,
NAME NVARCHAR2(255) NOT NULL,
BALANCE NUMBER(*,2) DEFAULT 0 NOT NULL,
IS_ACTIVE NUMBER(1) DEFAULT 0 NOT NULL,
IS_PREPAY NUMBER(1) DEFAULT 0 NOT NULL
);
CREATE TABLE MESSAGE_QUEUE(
ID NUMBER GENERATED BY DEFAULT AS IDENTITY NOT NULL,
ID_CLIENT NUMBER NOT NULL,
SENDER VARCHAR2(20),
RECIPIENT VARCHAR(20),
MESSAGE NVARCHAR2(255) NOT NULL,
QUEUED_ON TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
SEND_ON TIMESTAMP WITH TIME ZONE NULL,
SENT_ON TIMESTAMP WITH TIME ZONE NULL
);
CREATE TABLE TRANSACTIONS(
ID NUMBER GENERATED BY DEFAULT AS IDENTITY NOT NULL,
ID_CLIENT NUMBER NOT NULL,
VALUE NUMBER(*,2) NOT NULL,
TRANSACTION_TIME TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);
```
Для краткости, определения первичных и внешних ключей опущены.
#### Настройка окружения
Юнит-тестирование в SQL Developer использует базу данных для хранения тестов, их настроек, библиотеки, и результатов выполнения. В этих целях настоятельно рекомендуется создать пользователя для тестирования, затем создать в его базе данных репозиторий. Этот процесс более подробно описан в документации по юнит-тестированию [2].
#### Терминология тестирования Oracle
Терминология тестирования, которую использует Oracle несколько отличается от общепринятой терминоголии xUnit [3]:
| xUnit | SQL Developer | Комментарий к SQL Developer |
| --- | --- | --- |
| Набор тестов | Test Suite | Может включать другие наборы тестов и/или сценарии |
| Тестовый сценарий | Test | Может тестировать только одну функцию или процедуру |
| Тест | Test Implementation | |
| Настройка контекста (setup) | Startup Process | Доступна на уровне теста и набора тестов |
| Сброс контекста (tear down) | Teardown Process | см. выше |
Далее в тексте я буду использовать русский вариант терминологии xUnit.
#### Неожиданности
Работая с приложением, мы обнаружили, что оно не всегда работает так, как мы ожидали:
* Иногда, все пункты меню юнит-тестирования оказывались отключенными. В таких случаях необходимо щёлкнуть пункт меню **View→Unit Test**
* Все тесты внутри сценария используют общий набор настройки и сброса контекста, что вполне логично. Но из-за того, что редактируются они через вкладку теста, создаётся ощущение, что их можно персонализировать для каждого теста отдельно.
#### Разработка с помощью тестирования
Прежде чем мы сможем начать, необходимо создать пустую процедуру, а иначе невозможно будет создать тест. И хотя список аргументов можно оставить пустым, в этом нет никакой необходимости.
Изначально, мы можем предположить, что для того чтобы отправить сообщение, нам будет необходим идентификатор клиента, отправитель, получатель, а также тело самого сообщения. Также, нам необходимо сигнализировать результат выполнения, скажем, через выходной параметр. При помощи диалога создания процедуры можно получить вполне подходящее определение:
```
CREATE OR REPLACE PROCEDURE QUEUE_MESSAGE(
V_ID_CLIENT IN NUMBER,
V_SENDER IN VARCHAR2,
V_RECIPIENT IN VARCHAR2,
V_MESSAGE IN NVARCHAR2,
V_IS_QUEUED OUT NUMBER)
AS BEGIN
NULL;
END QUEUE_MESSAGE;
```
В случае с Oracle, имеет смысл задавать префикс для переменных, имя которых может совпасть с названием поля, так как в случае неясности, знаменитая СУБД решит спор в пользу поля. А во избежании беспорядка, проще давать префикс всем переменным без исключения.
> Примечание
>
>
>
> Если параметры процедуры изменились, то каждый её тестовый сценарий необходимо обновить вручную, щёлкнув пункт контекстного меню **Synchronize Test...**
#### Первый сценарий
Для упрощения нашего примера, допустим, что стоимость одного сообщения — `0.03` каких-то денег. И, как это ни странно, для описания сценария вполне подходит Gherkin:
```
Дано:
Активный пост-оплатный клиент
Когда:
Он отправляет сообщение
То:
Возвращается положительный результат,
И стоимость сообщения фиксируется в журнале транзакций,
К тому же, сообщение добавляется в очередь.
```
Самый быстрый способ создать тест — щёлкнуть правой кнопкой мыши на процедуре в дереве объектов, затем выбрать пункт меню **Create Unit Test...**. В появившемся окне можно сразу нажать кнопку **Finish**. Сценарий **QUEUE\_MESSAGE** с единственным тестом должен появиться в панели **Unit Test**.
##### Настройка контекста
Сначала нам необходимо будет заполнить базу необходмыми данными. Для нас самым удобным оказалось использование режима PL/SQL для настройки и сброса контекста. Тем не менее, любой из вариантов легко использовать повторно при помощи публикации в библиотеку. Чтобы скопировать существующий шаг из библиотеки, достаточно выбрать его из выпадающего списка, затем нажать кнопку **Copy**. А если нужно использовать его без изменений, но вместо кнопки **Copy** необходимо нажать чекбокс **Subscribe**.
> **Осторожно!**
>
>
>
> Идея использовать существующую БД для тестирования может показаться привлекательной. Казалось бы, сохранил данные в настройке, и восстановил при сбросе контекста… Однако следует иметь в виду, что если в процессе выполнения тестов на любом этапе произошла непредвиденная ошибка, то база данных окажется в том виде, в каком она была во время ошибки, и сброс контекста выполнен не будет. Поэтому лучше всего использовать чистую базу данных, которую не страшно и несложно полностью пересоздать в случае порчи структуры или данных.
Предполагая, что мы работаем с пустой базой данных, для настойки контекста, нам понадобится всего лишь одна вставка записи пост-оплатного клиента. Её можно тут же сохранить в библиотеке, назвав *Пост-оплатный клиент*.
##### Сброс контекста
Чтобы иметь возможность повторного прогона тестов, необходимо очистить добавленные данные. Однадко, в нашем случае, можно просто очистить все таблицы, затрагиваемые тестами. Этот шаг также нужно сохранить в библиотеку для дальнейшего использования.
##### Вызов
Непосредственно выполнение теста определяется при помощи задания параметров хранимой процедуры. Здесь же задаются и значения выходных параметров для проверки. Проверку выходных параметров можно отключить при помощи чекбокса **Test Result**. Он относится к параметрам, заданным как в таблице, так и динамически.
> **Осторожно!**
>
>
>
> С виду может показаться, что задавать параметры мышкой в таблице очень удобно, однако необходимо иметь в виду, что эта таблица копированию не подлежит. Это особенно важно для процедур с большим количеством аргументов, так как для создания очередного теста их все придётся заново задавать вручную, особенно когда новый тест отличается от текущего всего лишь на одно значение. Динамический запрос (Dynamic Value Query), в отличие от таблицы, можно сохранять в библиотеке, а затем можно либо повторно использовать, либо копировать.
Как указано выше, динамический запрос более удобен в использовании. Стоит также отметить, что название выходных параметров в запросе должно быть дополнено знаком `$` в конце названия:
```
select 1 as V_ID_CLIENT, '79052222222' as V_SENDER, '79161111111' as V_RECIPIENT,
'Айда гулять!' AS V_MESSAGE, 1 as V_IS_QUEUED$ from DUAL
```
> Примечание
>
>
>
> Чтобы вернутся из режима динамического запроса в табличный, необходимо полностью очистить значение динамического запроса.
Так как мы указали проверку выходного параметра, то уже можно запустить сценарий, и увидеть сбой. Если всё сделано правильно, система должно сообщить об ошибке. Любой другой сбой на этом этапе означает некорректную настройку.
Самый простой способ успокоить тест — внаглую вписать `1` в выходной параметр в теле процедуры: `SELECT 1 INTO IS_QUEUED FROM DUAL;`
##### Утверждения
Тест снова зелёный, но мы ещё не проверили все необходимые условия. Их можно проверить в других тестах того же сценария. Перед тем как создавать новый тест, стоит переименовать существующий из дефолтного "Test Implementation 1" в "Положительный результат", а весь сценарий — в "Активный пост-оплатный клиент отправляет сообщение".
> **Важно**
>
>
>
> Легко предположить, что каждый тест выполняется внутри транзакции. Однако на поверку это оказалось не так. В случае возникновения непредвиденной ошибки, база данных может оказаться в непределённом состоянии. Ожидаемых ошибок такое поведение не касается.
Наша следующая проверка будет помещена в отдельный тест для получения более тонкой обратной связи, однако, стоит помнить, что каждый новый тест будет затрачивать время на настройку и сброс контекста, а каждый сбой проверки снабжается чётким сообщением о его причине. Мы разделим проверки по разным тестам в этом сценарии, а потом объединим все проверки в один тест в следующем сценарии.
> **Примечание**
>
>
>
> SQL Developer не позволяет просматривать два теста одновременно. При переходе к другому тесту в дереве, текущий тест заменяется новым в той же панели. Помимо того, невозможно разбить эту панель на две независимо прокручиваемые области. Однако, очень удобно открыть исходный код процедуры параллельно с окном теста для быстрого перехода между двумя панелями.
Следующий тест должен проверить, что сообщение помещено в очередь. Так как настройка и сброс контекста уже указаны, нам необходимо использовать динамический запрос из библиотеки, и задать проверку утверждения. После того как мы скопировали динамический запрос, может показаться, что проверять уже проверенный выходной параметр ни к чему, и можно сбросить чекбокс *Test Result*. Однако, если прогнать тесты в таком состоянии, то будет видно, что один из тестов проигнорирован. Лично для меня проигнорированный тест — символ незаконченной работы, поэтому флажок придётся поставить на место.
Существует несколько способов проверки утверждений. Первым пунктом в списке — булевая функция. При создании булевой функции, диалог предоставляет вполне подходящий шаблон:
```
-- Please replace this code with either a boolean
-- expression like this:
-- RETURN FALSE;
-- or else a code block which returns a boolean value
-- similar to the following:
DECLARE
l_count NUMBER;
BEGIN
SELECT count(*) INTO l_count FROM dual;
IF l_count <> 0
THEN
RETURN TRUE;
ELSE
RETURN FALSE;
END IF;
END;
```
Для нашей проверки мы можем использовать этот шаблон, заменив `dual` на `MESSAGE_QUEUE`, затем применив необходимые фильтры. Условие также придётся сменить с `l_count <> 0` на `l_count = 1` для большей точности. После этого можно смело сохранять функцию в библиотеку для дальнейшего использования.
> **Примечание**
>
>
>
> Все записи в библиотеке сохраняются согласно своему типу. Это означает, что, если в дальнейшем понадобится использовать, например, проверку утверждения, необходимо будет помнить не только её название, но и тип. Это очень быстро может оказаться весьма неудобным, особенно в крупных проектах.
При прогоне тестов мы должны увидеть ошибку. Её очень легко исправить:
```
INSERT INTO MESSAGE_QUEUE(ID_CLIENT, SENDER, RECIPIENT, MESSAGE)
VALUES(V_ID_CLIENT, V_SENDER, V_RECIPIENT, V_MESSAGE);
```
Теперь можно убедиться, что все тесты проходят с успехом.
> **Примечание**
>
>
>
> При работе с тестами репозиторий блокируется, поэтому по окончании работы необходимо либо закрыть SQL Developer, либо закрыть репозиторий (Deselect Repository).
И, напоследок, проверим запись транзакции. Для этого выберем следующий тип валидации — сравнение результатов запросов (Compare Query Results). Как и следует из названия, он работает очень просто: нужно указать два запроса, результаты которых совпадут. Так как точную дату и время узнать невозможно, можно довольствоваться люб значение в пределах 10 секунд:
```
-- Source query
SELECT 1 AS ID_CLIENT, 0.03 AS SUM_VALUE FROM DUAL
-- Target query
SELECT ID_CLIENT, SUM(VALUE) FROM TRANSACTIONS
WHERE TRANSACTION_TIME BETWEEN CURRENT_TIMESTAMP AND (CURRENT_TIMESTAMP - 1/24/6)
GROUP BY ID_CLIENT;
```
После прогона тестов мы видим расплывчатую ошибку `Validation одна недавняя транзакция: Compare query results check found differences`. Где "одна недавняя транзакция" — название нашей последней проверки в библиотеке. И хотя этот вариант уже является ценным инструментом, было бы замечательно, если бы он мог показать чем же именно результаты отличаются.
Добавим нужный функционал в нашу процедуру:
```
INSERT INTO TRANSACTIONS(ID_CLIENT, VALUE) VALUES(V_ID_CLIENT, 0.03);
```
##### Отладка
После очередного прогона тестов вдруг выясняется, что ошибка никуда не делась. Вы, наверное, уже заметили ошибку в коде выше, однако в реальных условиях ситуации бывают куда более сложными. Так как разницы инструмент на показывает, придётся выяснять причину вручную. К сожалению, отладочный функционал SQL Developer здесь ничем помочь не в состоянии. Это значит, что нам придётся прогнать тест без выполнения сброса. Для этого можно создать ещё один сценарий — отладочный. А точнее два: один — без сброса, но с тем же динамическим запросом, что и в нерабочем тесте — для того чтобы разобраться в чём дело; а второй — без настройки контекста, но со сбросом — для того чтобы убрать за первым.
После запуска первого сценария можно посмотреть содержимое таблицы, и свериться с проверочным запросом. Теперь чётко видно, что проблема заключалась именно в проверочном запросе. Не забыв запустить второй сценарий для очистки данных, поправляем условия теста, и устраиваем повторный прогон. Теперь всё в порядке. Отладочные сценарии можно оставить на будущее, а первый законченный сценарий можно поместить в новый набор тестов.
#### Второй сценарий
Теперь когда у нас есть сценарий успешной оправки сообщения, мы можем попробовать сценарий неудачной отправки. Например, когда пост-оплатный клиент неактивен:
```
Дано:
Неактивный пост-оплатный клиент
Когда:
Он отправляет сообщение
То:
Возвращается отрицательный результат,
и транзакция не фиксируется,
и очередь сообщений остаётся неизменной.
```
Необходимо создать новый сценарий. Нам также придётся слегка подправить настройку контекста и динамический запрос, но это уже гораздо проще, чем создавать новые с нуля.
Для настройки контекста копируем PL/SQL шаг "Активный пост-оплатный клиент", в котором заменяем `1` на `0` и публикуем в библиотеке под названием "Неактивный пост-оплатный клиент". Повторяем то же для динамического запроса, назвав новый запрос "Неотправленное сообщение". Для сброса контекста используем существующий шаг.
После прогона тест должен показать ошибку. Её очень легко исправить. Заменяем `SELECT 1 INTO V_IS_QUEUED FROM DUAL` на `SELECT IS_ACTIVE INTO V_IS_QUEUED FROM CLIENTS WHERE ID=V_ID_CLIENT` — и всё снова работает.
Затем необходимо проверить, чтобы транзакция не сохранялась. Для этого используем следующий тип проверки — сравнение таблиц (Compare tables). Поначалу может показаться, что сравнивать не с чем, однако, в настройке контекста есть возможность скопировать существующую таблицу во временную. Нам это прекрасно подходит — можно скопировать транзакции во временную таблицу, а после вызова процедуры сравнить результаты. Главное — не забыть эту таблицу удалить при сбросе контекста. Есть два варианта — восстановить, затем удаилить, и просто удалить. Так как восстанавливать нам нечего — выберем второй вариант. Обратите внимание, что как и в случае со сравнением запросов, единственный вариант обратной связи — есть совпадение или нет.
Полюбовавшись на ошибку после прогона тестов, можно подумать над решением. Например, можно обернуть вставку в условие, исользуя свеже-обновлённый V\_IS\_QUEUED:
```
IF V_IS_QUEUED = 1 THEN
INSERT INTO TRANSACTIONS (ID_CLIENT, VALUE) VALUES (V_ID_CLIENT, 0.03);
END IF;
```
Компилируем процедуру, прогоняем тесты — всё работает.
В заключение, нам надо проверить, что очередь сообщений осталась без изменений. И хотя руки чесались сразу же поместить вставку сообщения внутрь условия рядом со вставкой транзакции, это было бы поощрением нарушения дисциплины. Поэтому сначала создадим дополнительную проверку для этого утверждения. Следующий тип проверки — Запрос, не возвращающий записей (Query returning no rows). Так как мы полностью очищаем все данные после каждого теста, достаточно будет указать `SELECT * FROM MESSAGE_QUEUE` в качестве такого запроса.
Прогон тестов показывает ошибку, которую мы с лёгкостью устраняем, помещая вставку внутрь условия. И на этом заканчивается наш второй сценарий.
#### Выводы
SQL Developer можно использовать для разработки хранимых процедур методом TDD. Невзирая на многочисленные недостатки, этот пакет предоставляет платформу для разработки хранимых процедур, позволяя разработчикам с лёгкостью и уверенностью менять и расширять функционал существующих процедур.
К сожалению, тестовый репозиторий можно создать только в СУБД Oracle. Кроме того, попытки использовать сторонние СУБД типа PostgreSQL или даже MySQL в качестве базы данных для тестирования, заканчиваются крахом подсистемы теститования. Также выяснилось, что использование SQL Developer в системах непрерывной интеграции вызывает массу проблем, но это уже отдельная история.
---
[1] Oracle SQL Developer (англ.) — <http://www.oracle.com/technetwork/developer-tools/sql-developer/overview/index.html>
[2] Oracle SQL Developer Help: Unit Testing Repository (англ.) — <https://docs.oracle.com/cd/E15846_01/doc.21/e15222/unit_testing.htm#RPTUG45067>
[3] xUnit — <https://ru.wikipedia.org/wiki/XUnit> | https://habr.com/ru/post/304888/ | null | ru | null |
# Пишем небесных пчелок на Cloud Haskell
Привет, Хабр!
Прошло всего лишь каких-то 11577635 секунд с конца осенней школы GoTo в ИТМО. Неделя направления Распределённых систем началась с прототипирования распределённой системы на Cloud Haskell. Мы начали бодро и потому быстро выяснили, что существующую документацию без PhD понять сложновато — и решили написать методичку.
Под катом введение в p2p cloud haskell, немножко функционального стека прототипирования РС, мотивация и «но зачем».
---
Положим, вам захотелось сделать что-то такое распределённое ~~(скажем, %sCoin)~~, что не покрывается хорошо существующими системами (YARN таки не ответ на все вопросы). Если начать делать всё руками, можно быстро обнаружить огромное количество проблем — от мультиплексирования соединений и шифрования до пробива NAT и peer routing, которые совсем, очень не хочется решать (не в первый раз в истории человечества), особенно если цель — конечный продукт или красивый, *работающий* прототип.
Любому прикладному программисту от такой постановки задачи быстро придёт в голову слово «библиотека». И действительно. Можно взять discovery и кусочки routing из, например, Kademlia, стандартные механизмы пробива NAT — STUN, TURN, ICE — в общем, тоже известны, для шифрования — ну, прибьём TCP (зная специфику своей сети) и сделаем TLS 1.3 с захардкоженными шифрами, etc.
Но это всё ещё будет требовать много времени и экспертизы. Инвесторам терпения может и не хватить.
Здесь более опытным коллегам придёт мысль: «нужен фреймворк!». И правда. Для Прототипирования Распределённых Систем и Приложений.
А кто-то даже скажет: б-же, так это же [libp2p](https://libp2p.io)! И будет прав. Частично.
libp2p решает проблему транспорта, его мультиплексирования и шифрования, discovery, peer routing, пробива NAT, connection upgrade и т.д. — в общем, многие сетевые и криптопотребности распределённых приложений. На Go и JS.
Это отличный фреймворк, но у него есть пара проблем. Это Go и JS. Кроме того, было бы приятно иметь во фреймворке что-нибудь для репликации.
---
> the fragmented nature of the tutorials, some of which didn’t work at all, convinced me to not use Cloud Haskell
*<http://www.scs.stanford.edu/14sp-cs240h/projects/joshi.pdf>, перефразировано*
Наш проект начался с амбиции сделать блокчейн (простите, инновации) на Хаскелле — поэтому libp2p у нас не было — и за четыре дня. Мы начали искать нечто, что сделало бы сеть (транспорт, discovery, сериализацию) за нас. Нашли [Cloud Haskell](https://haskell-distributed.github.io/). Обнаружили, что с документацией сложновато. Решили написать своё введение. Итак:
[Пишем небесных пчелок на Cloud Haskell
======================================](#pishiem-niebiesnykh-pchielok-na-cloud-haskell)
В примере мы напишем систему из пчелок: есть улей — кластер машин, и пчелки — ноды (машины). Пчелки отправляются на разведку искать цветочки и возвращаются с координатами вкусных цветочков в улей, а все другие пчелки должны об этих координатах узнать.
Вам вовсе не обязательно запускать программу на нескольких компьютерах — достаточно и ноутбука, на котором мы параллельно запустим нашу программу.
Полный код находится в [репозитории](https://github.com/SenchoPens/cloud-bees).
Cloud Haskell работает по принципу обмена сообщений между нодами (такая модель называется *message passing*), потому что ноды не разделяют общее пространство ресурсов (RAM, …) — модель *shared state* легко использовать не получится. *Actor Model* — частный пример модели *message passing*, когда сообщения рассылают *акторы* другим акторам и принимают сообщения в свой *mailbox* — так message passing выглядит в Cloud Haskell.
---
**1.** Для начала определим типы данных, представителями которых будут обмениваться пчелы: *src/Types.hs*
```
type Flower = (Int, Int) -- координаты цветка
type Flowers = GSet Flower -- Grow-Only Set цветков
```
* Пчелы должны знать о каждом цветке, известном хотя бы одной пчелке в улье, следовательно им необходимо поддерживать единое состояние «базы данных» цветков в своем пчелином мозгу — решить проблему *репликации данных*, для чего нужно уметь достигать *консенсус*: разрешать конфликты между базами данных разных пчел. Для этого мы будем использовать структуру данных *GSet* (Grow-only Set) — множество, в которое элементы можно только **добавлять**, но **не удалять**. Это одна из структур данных [*CRDT*](https://habrahabr.ru/post/272987/). Для работы с GSet на Хаскелле мы воспользовались прекрасной библиотекой [crdt](https://hackage.haskell.org/package/crdt) Юрия Сыровецкого ([@cblp](https://habr.com/users/cblp/)). *```
Log A Log B
| |
logA.append("one") logA.append("two")
| |
v v
+-----+ +-------+
|"one"| |"hello"|
+-----+ +-------+
| |
logA.append("two") logA.append("world")
| |
v v
+-----------+ +---------------+
|"one","two"| |"hello","world"|
+-----------+ +---------------+
| |
| |
logA.join(logB) <----------+
|
v
+---------------------------+
|"one","hello","two","world"|
+---------------------------+
```
Схема достижения консенсуса с помощью CRDT (Из <https://github.com/haadcode/ipfs-log>)*
* Необходим интерфейс, который будет служить рецепторами пчелки: добавление элемента в GSet, а также просмотр вкусных цветочков, известных улью — реализуем это в виде REPL (интерактивной оболочки).
**2.** Приступим к реализации ноды, которую в дальнейшем будем запускать из командной строки: *app/Main.hs*
```
main = do -- точка входа
[port, bootstrapPort] <- getArgs -- (1) считываем порт ноды и bootstrap ноды из аргументов командной строки
let hostName = "127.0.0.1" -- IP ноды
P2P.bootstrap -- вызываем функцию инициализации ноды со следующими аргументами:
hostName
port -- порт ноды
(\port -> (hostName, port))
initRemoteTable -- (2) создаем remote table
[P2P.makeNodeId (hostName ++ ":" ++ bootstrapPort)] -- список из одной bootstrap ноды
spawnNode -- функция запуска логики ноды, ее код мы напишем потом
```
1. Для начала ноды должны как-то друг о друге узнать, то есть совершить *peer discovery*. В Cloud Haskell есть решение ‘из коробки’ — при инициализации ноды нам достаточно указать хотя бы одну другую *bootstrap* ноду: нода совершает с bootstrap нодой *Peer Exchange* — они обмениваются адресами знакомых им нод (aka *пиров*).
2. *Remote table* — штука, которая позволяет пирам обмениваться типами haskell, если они поддерживают *сериализацию*, то есть их можно представить в формате, который можно переслать по сети и восстановить обратно в обьект Haskell. Тип поддерживает сериализацию, если он реализовывает тайпкласс `class (Binary a, Typeable) => Serializable a`. Вам не надо самому придумывать реализацию `Serializable`, `Binary` и `Typeable` — haskell сделает это за вас (с помощью магического механизма automatic deriving):
```
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-} -- прагмы языка, позволяющие автоматически реализовать Binary
data Example = Example
deriving (Typeable, Generic)
instance Binary Example
```
Далее мы будем опускать `deriving ...`, `instance Binary` и прагмы ради краткости кода.
**3.** Теперь напишем логику запуска ноды:
```
spawnNode :: Process () -- (1) функция запуска логики ноды
spawnNode = do
liftIO $ threadDelay 3000000 -- даем bootstrap ноде время чтобы запуститься
let flowers = S.initial :: Flowers -- инициализирум GSet для хранения координат цветков
self <- getSelfPid -- (3) получаем наш Pid чтобы REPL мог посылать нам сообщения
repl <- spawnLocal $ runRepl self -- (2) создаем REPL в отдельном потоке
register "bees" self -- теперь нода будет получать сообщения из канала "bees"
spawnLocal $ forever $ do -- (3) запускаем тикер:
send self Tick -- оповестить основной поток что надо передать пирам свое состояние
liftIO $ threadDelay $ 10^6 -- ждемс 0.1 секунды перед тем, как снова отослать состояние
runNode (NodeConfig repl) flowers -- (5) запускаем ноду
```
1. В Cloud Haskell основная функциональная единица это `Process` (не путайте с процессом ОС). Они основаны на легковесных зеленых потоках и могут посылать другим процессам сообщения (функция `send` чтобы послать определенному процессу или `P2P.nsendPeers` чтобы послать всем знакомым нодам), принимать сообщения в свой *mailbox* (функция `expect` или `receive*`), запускать другие процессы (например локально с помощью `spawnLocal`) и т.д.
2. Нам необходимо реализовать REPL в отдельном потоке, иначе будет происходить блокировка основного потока (ноды), следовательно надо сделать потоко-безопасный интерфейс для GSet, чтобы он был доступен для изменения как для REPL, так и для ноды. Так как система основана на акторах, мы будем посылать сообщения на изменение множества и обрабатывать их последовательно в бесконечном цикле обработки соообщений в главном потоке.
3. Мы запускаем REPL как отдельный процесс cloud-haskell (т.е. как зеленый поток), и также передаем ему Pid основного процесса (уникальный идентификатор процесса) чтобы REPL знал, куда посылать команды, введенные пользователем, в виде сообщений. Далее мы получаем Pid REPL’а (его возвращает `spawnLocal`) чтобы посылать ему ответы на команды. Код REPL лежит [тут](https://github.com/SenchoPens/cloud-bees/blob/master/src/Repl.hs).
4. Как будет работать репликация цветков?
* Каждая нода будет периодически рассылать свое состояние всем пирам (*broadcast*) — и это в совокупности с CRDT решает проблему репликации:
Пусть есть ноды `A` и `B`. Предположим у `A` нет элемента **x**, а у `B` **x** есть. После того, как `B` совершит broadcast, `A` добавит **x** — консенсус достигнут, ч.т.д.
Если бы мы имели обыкновенное множество, а не GSet, то ничего бы не получилось: Предположим у `A` и `B` есть элемент **y**. Пусть `A` удалит **y**. После того, как `B` совершит broadcast, `A` получит **y** обратно.
* Когда мы посылаем сообщение всем нодам, мы должны указать имя *сервиса* — на самом деле мы посылаем сообщение только тем нодам, которые зарегистрировали себя в *регистре* как поддерживающиe этот сервис. Здесь мы регистрируем нашу ноду как поддерживающую сервис “bees”: `register "bees" self`.
* Нода должна знать, когда надо послать другим свое состояние. Самое простое решение — делать это по таймеру: ждать секунду, а потом действовать, но тогда бы мы блокировали основной поток обработки сообщений. Здесь мы запускаем процесс через `spawnLocal`, который сначала посылает сообщение Tick главному процессу (когда главный процесс видет Tick, он посылает нодам свое состояние), а потом ждет 1 секунду и повторяет.
**4.** Ок, теперь (наконец-то!) мы можем приступить к логике работы основного процесса — код исполнения ноды:
```
runNode :: NodeConfig -> Flowers -> Process () -- (1) функция логики ноды
runNode config@(NodeConfig repl) flowers = do
let run = runNode config
receiveWait -- (2) ждем сообщений
[ match (\command -> -- (3) если нам пришло что-то типа Command от REPL, то
newFlowers <- handleReplCommand config flowers -- получаем новое состояние цветков
run newFlowers)
, match (\Tick -> do -- сигнал о том, что надо поделиться своим состоянием с другими
P2P.nsendPeers "bees" flowers -- отправить всем пирам цветки
run flowers)
, match (\newFlowers -> do -- кто-то отправил ноде цветочки
run $ newFlowers `union` flowers) -- добавляем новые в базу - по сути обьединение множеств
]
```
1. Посмотрим на сигнатуру: `runNode` принимает конфигурацию ноды типа `NodeConfig` — та информация, которая не будет меняться во время исполнения. В нашем случае это просто Pid REPL. Еще она принимает свое текущее состояние — GSet цветочков. Но как добавить цветок, ведь GSet — неизменяемый тип данных? Очень просто: сделаем нашу функцию рекурсивной, и при каждом изменении состояния будем запускать ее заново.
2. `receiveWait` принимает список функций с одним аргументом (входящим сообщением), вытаскивает сообщение и вызывает функцию, подходящую по типу сообщения.
3. Если нам пришло сообщение такого типа: `data Command = Add Flower | Show`, то это — команда от REPL. `handleReplCommmand` — функция для обработки команды:
```
handleReplCommand :: NodeConfig -> Flowers -> Command -> Process Flowers
handleReplCommand (NodeConfig repl) flowers (Add flower) = do -- команда добавления элемента от пользователя
send repl (Added flower) -- отправить REPLу сообщение, что цветок добавлен
return $ S.add flower flowers -- запускаем ее уже с новым цветком
handleReplCommand (NodeConfig repl) flowers Show = do -- запрос показать цветочки
send repl (HereUR $ toList flowers) -- отправить цветочки в виде списка
return flowers
```
4. Если пришел Tick от тикера — значит надо отправить свое состояние: `P2P.nsendPeers "bees" flowers`. Здесь “bees” — имя сервиса, то есть мы пересылаем цветки только тем нодам, которые зарегистрировали себя как “bees”.
5. Если же нам пришли цветочки от какой-то другой пчелки, нам надо все незнакомые цветки добавить себе, то есть попросту объединить множество новых с множеством существующих.
**5.** Вот и все! Загрузим полный исходный код и скомпилируем:
```
git clone https://github.com/SenchoPens/cloud-bees.git
cd cloud-bees
stack setup # Stack установит GHC
stack build # Компилируем
```
Теперь запустите в одном терминале эту строчку:
```
stack exec cloud-bees-exe 9000 9001 2>/dev/null
```
И в другом эту:
```
stack exec cloud-bees-exe 9001 9000 2>/dev/null
```
REPL выведет приглашение. Попробуйте в одном терминале ввести `Add (1, 2)`, т.е. добавить цветок с координатами (1, 2), а в другом — `Show`, и увидите, что и у второй ноды теперь есть такой цветок.
* Часть `2>/dev/null` нужна чтобы скрыть stderr, в который Cloud Haskell выводит лог. Если этого не сделать, то мы не сможем нормально пользоваться REPL. Можете заменить `/dev/null` на `log.txt` и потом посмотреть, что же он вывел.
---
Надеюсь, мы убедили вас, что создание распределенных систем на Haskell — это не так уж и страшно :)
Можно придумать много реальных юз-кейсов для похожей системы: например, решение проблемы зайцев в общественном транспорте: человек, проходя в транспорт по карточке, маркируется как зашедший (добавляем его id в первый GSet), а на выходе — как вышедший (добавляем id во второй GSet). Ночью (когда транспорт не работает) происходит проверка — если человек вошел и вышел, то он не заяц.
Если вам интересно — можете посмотреть наш [более обьемный проект с шифрованием, который мы сделали во время смены](https://github.com/mreluzeon/block-monad).
---
*С любовью, Арсений и компания, 9 класс; под нежным руководством [wldhx](https://habr.com/users/wldhx/)* | https://habr.com/ru/post/351496/ | null | ru | null |
# nocc — распределённый компилятор для гигантских проектов на С++
У нас есть задача постоянно компилировать тонны плюсового кода. Наш проект — почти 200 000 cpp- и h-файлов, множество Git-веток, сотни разработчиков, десятки билд-агентов: его нельзя единожды скомпилировать, приходится перекомпилировать постоянно, параллельно, разные версии.
Наш проект необычный. Потому что эти 200 000 файлов — это результат автогенерации. Потому что пишем мы на PHP, а потом через [KPHP](https://github.com/VKCOM/kphp) все PHP-исходники превращаются в плюсы. Именно так разрабатывается бэкенд ВКонтакте.
Компилировать тысячи объектников долго. Локально это занимает много часов. Мы использовали [distcc](https://github.com/distcc/distcc) — но всё равно медленно. Мы даже пропатчили distcc для поддержки precompiled headers — но даже тогда медленно. И решили написать своё — чтоб стало, наконец, быстро.
В итоге мы написали замену distcc — компилятор nocc. Он не имеет никакого отношения к PHP и даже к KPHP, а просто предназначен для компиляции *.cpp* *→* *.o* в промышленных масштабах.
Это техническая статья про параллелизацию, демоны и специфику С++. Ссылки на GitHub и видео приложу в конце статьи.
Как вообще можно ускорить компиляцию С++
----------------------------------------
Основная идея у nocc и у distcc одинаковая: компиляция происходит не локально, а удалённо. То есть отдельно стоят серверы (компиляционные ноды, *nocc-server*), а клиент проксирует вызов *g++/clang* туда. Для этого клиенту вместо `g++ 1.cpp ...` достаточно вызвать `nocc g++ 1.cpp ...` — и файл будет скомпилирован не локально, а удалённо.
Скорость обеспечивается за счёт того, что серверов много (у нас 32 в бою, например). Получается, если локально можно было запускать, к примеру, `make -j40`, то теперь можно `make -j400`, и nocc-клиент равномерно размажет это по серверам.
То есть nocc — это такая тонкая прослойка, которая умеет загружать файлы и проксировать командную строку. А ещё это очень умный кеш, чтобы не загружать один и тот же файл заново. И даже не компилировать повторно.
Запуск nocc прозрачен для клиента
---------------------------------
С точки зрения вызова, билд-система должна уметь всего лишь одну простую штуку: подставлять произвольную строчку перед плюсовым компилятором, чтобы получилось `nocc g++ ...`.
Это можно сделать и в make, и в CMake, и в Ninja. Например, для CMake это выглядит так:
```
cmake -DCMAKE_CXX_COMPILER_LAUNCHER=/path/to/nocc ..
```
И всё, nocc-клиент будет отсылать .cpp на серваки.
Если командная строка невалидна или её нельзя выполнить удалённо, nocc просто исполняет её локально, и всё. Например, форсирует локальное исполнение без изменения опций. Например, линковка происходит локально. Или `-march=native` происходит локально. Если сервак недоступен, то опять-таки фоллбечимся. Поэтому вызов nocc безопасен всегда.
Клиентский nocc-процесс завершается с тем же exitCode / stdout / stderr, что и удалённый g++, поэтому вывод консоли останется без изменений.
Что происходит при `nocc g++ 1.cpp`
-----------------------------------
Пусть есть *1.cpp*:
```
#include "1.h"
int square(int a) {
return a * a;
}
```
И простой *1.h*:
```
int square(int a);
```
Вот что происходит при запуске `nocc g++ 1.cpp -o 1.o -c`:
* nocc парсит командную строку: входной файл, пути к инклудам, cxx-флаги и пр.;
* для входного файла (*1.cpp*) nocc находит все зависимости, сканируя все `#include` рекурсивно (в примере это просто файл *1.h*);
* nocc загружает файлы на выбранный сервер и ждёт;
* nocc-server выполняет ту же командную строку (те же cxx-флаги, только пути подменены);
* nocc-server пушит *1.o* обратно;
* nocc сохраняет *1.o* — будто бы сделанный локально.
В реальности мы ставим много серверов для компиляции
----------------------------------------------------
На клиентской стороне запускается куча nocc-процессов одновременно. Каждый запуск — один *.cpp* *→* *.o* вызов, прозрачно для билд-системы. Он компилирует файл удалённо и умирает, ведь nocc это просто тонкая прослойка к ремоуту.
Для каждого cpp выбирается удалённый сервер, вычисляются все зависимости, недостающие загружаются, и сервер отправляет обратно готовый объектник. Это происходит параллельно для всех клиентов.
Для большей производительности все коннекты на самом деле держит один nocc-daemon:
nocc-демон написан на Go — а nocc очень лёгкая обёртка C++ с единственной целью: передать командную строку в демон, дождаться ответа и умереть.
Получается, итоговая схема работы такая:
1. Самый первый запуск nocc стартует nocc-демон в фоне: демон коннектится по gRPC к сервакам и в целом делает всю работу.
2. Каждый nocc-вызов отправляет `g++ ...` в демон через Unix-сокет, демон ждёт объектник, сохраняет его, и nocc-процесс умирает.
3. nocc-процессы стартуют и умирают: билд-система сама запускает их, не задумываясь об этом.
4. nocc-демон умирает через 15 секунд (эвристическая оценка того, что процесс компиляции завершился).
nocc — это очень умный распределённый кеш
-----------------------------------------
Главная фишка на практике заключается в том, что второй, третий и последующие запуски быстрее, чем первый. Даже если почистить папку build, даже на другой машине, даже в другой папке.
Это всё благодаря удалённым кешам:
* **кеш исходников** — nocc не загружает файл, если он уже был загружен;
* **кеш объектников** — nocc не компилирует файл, если он уже был скомпилирован.
Такой подход значительно уменьшает времена сборок на различных билд-агентах, даже если локальные кеши дропнуты или билд-агент новый.
Более того, это прекрасно ложится на Git-разработку. Кто-то сбилдил свою ветку, а потом вмержился в мастер — а на сервере есть уже готовые объектники. И неважно, что у нас PHP, а С++ получается на выходе — это всё равно работает.
Кеш исходников работает на хешах от файлов. Когда nocc ищет `#include` рекурсивно, для всех файлов он считает SHA256. Изначально он отправляет серваку список хешей — а сервак отвечает, какие отсутствуют. Чаще всего при повторных компиляциях уже всё есть, и аплоадить ничего не нужно. Файлы вытесняются по LRU и не превышают заданный объём на диске.
Кеш объектников устроен похожим образом. Мы комбинируем хеши всех зависимостей, а также все cxx-опции — тоже получаем SHA256, которым индексируем объектник. Так что при повторной компиляции тех же исходников с теми же опциями объектник будет уже готов. Легко понять, что одному cpp-файлу могут соответствовать несколько объектников. Например, с дебаг-символами и без них — это разные опции командной строки, приводят к разным хешам, и оба объектника хранятся в объектном кеше, они оба готовы. Это не какой-то исключительный случай, так само получается, и получается хорошо.
Некоторые сведения из архитектуры и реализации nocc
---------------------------------------------------
* **Как nocc выбирает сервер для компиляции**
Очень просто на самом деле: *(хеш от имени файла) % N*. Безо всякой там балансировки по нагрузке и так далее — просто хеш от basename, даже без папки.
Логика простая: на разных CI-машинах билд проекта идёт в разных tmp-папках, а мы хотим, чтобы одни и те же cpp (и их инклуды, что важно) попадали всегда на одни и те же ноды.
Даже если сам cpp изменился, вероятнее всего, большинство инклудов осталось прежними, зачем их лить заново. Даже если сервак недоступен, не нужно отправлять на другой, а лучше исполнить локально: сервак быстро поднимут, а мусор на других серваках не нужен.
* **Как происходит удалённая компиляция**
Каждый демон имеет уникальный *clientID*, и все файлы, которые он заливает (cpp, h, inc, gch) складываются в отдельную папку (working dir), фактически зеркалируя файловую структуру клиента. Всё что нужно — это при запуске g++ подменить пути:
Когда файлы зависят от системных хедеров (типа ), они тоже проверяются, но загружаются только при различиях. Одинаковые системные файлы можно не загружать, `#include` на сервере отработает так же.
Напомню, что на серваке есть кеш исходников. Те зависимости, которые уже загружались, берутся из кеша: просто делается хардлинка в тот же working dir. Это равносильно тому, что файл загружен, так что g++ его прекрасно увидит по нужному пути.
* **Кастомная парсилка** `#include`
Для каждого cpp нужно собрать рекурсивное дерево зависимостей.
Можно было бы сделать это через флаг `g++ -M`: он запускает только препроцессор (не компиляцию), а выдаёт список зависимостей (а не результат препроцессора).
Но в nocc встроен собственный парсер инклудов, который делает то же самое, только в разы быстрее. Он сам парсит cpp- и h-файлы, находит `#include`, резолвит их и продолжает рекурсивно. Он учитывает `-I / -iquote / -isystem` из командной строки, знает про системные пути и даже про `#include_next`. Быстрее это потому, что работает в демоне, и мы там можем всё кешировать: инклуды из разных cpp часто пересекаются, а при билде часто используются одни и те же пути в опциях. Получается, не нужно на каждый cpp вызывать препроцессор, и это ощутимо экономит время.
Конечно, в отличие от `g++ -M`, nocc ничего не делает с `#ifndef` и прочими. Поэтому он находит больше инклудов, чем нужно, и какие-то даже могут не существовать. Но это нормально, потому что потом при удалённой компиляции они будут просто недостижимы, и удалённый g++ невозмутимо отработает.
И кстати, параллельно с поиском инклудов считаются и хеши всех зависимостей, ведь контент файла мы уже загрузили.
Кастомная парсилка инклудов работает, только когда они могут быть статически зарезолвлены. Всякие там `#include MACRO()` не раскроешь, тут нужен честный препроцессор на клиентской стороне. Какой-нибудь boost активно это использует, поэтому с проектами на boost'е печаль. Есть опция, чтобы отключить кастомную парсилку. Отключение, конечно, замедляет, но в итоге всё равно получается выиграть у distcc по скорости.
* **Precompiled headers**
nocc их поддерживает, причём по-хитрому. Когда клиентский код хочет сделать pch:
```
nocc g++ -x c++-header -o all-headers.h.gch all-headers.h
```
… то nocc это перехватывает и делает `all-headers.h.nocc-pch` **вместо** .`gch/.pch` на клиенте — и потом компилирует на сервере в реальный `.gch/.pch`.
Две главных причины для такого:
1. Если делать gch локально, его всё равно нужно залить на все серваки. Но gch-файлы большие, и одновременный аплоад на N серверов упарывает сеть.
2. Если .gch-файлы (g++) могут работать после заливки, то .pch (clang) — уже нет. Clang не будет использовать файл, скомпилированный на другой машине, и хитрые опции типа `--relocatable-pch` тут не помогут.
Файлик *.nocc-pch* — это просто текст с содержимым всех зависимостей. Клиентский nocc его делает быстро — значительно быстрее, чем клиентский g++ делает gch.
Когда работает кастомная парсилка инклудов, то, видя `#include "all-headers.h"`, она находит `all-headers.h.nocc-pch` и загружает его как обычную зависимость. После загрузки сервер делает настоящий precompiled header и сохраняет `all-headers.h` и `all-headers.h.gch` до рестарта. А потом при использовании также делаются хардлинки в нужные места в working dir разных клиентов.
На клиенте gch не делается: если всё хорошо, он не нужен. Если же сеть недоступна и nocc пойдёт локально, компиляция отработает и без gch, ничего не сломается.
Что это дало и стоило ли всё это придумывать?
---------------------------------------------
Да, стоило. Экономим много. VKCOM — гигантский монолит, и каждый разработчик постоянно хочет пересобирать свою версию.
Я говорил, что мы раньше использовали distcc. Он работает совсем по-другому, вообще не похоже на nocc, но это тоже удалённая компиляция. Разработчики distcc [пишут](https://www.distcc.org/), что есть pump mode, который делает немножко похоже, но нам не удалось заставить его работать. Возможно, на синтетических тестах он работает, а на реальных объёмах нет. Именно поэтому ещё три года назад мы пропатчили distcc, сделав ему поддержку pch-заголовков.
Поэтому будем сравнивать: оригинальный distcc, наш патченный distcc, первый nocc-запуск и последующие запуски nocc (в чистой клиентской папке).
| | |
| --- | --- |
| Оригинальный distcc | 10077,2 с. |
| Патченный distcc + pch | 660,9 с. |
| nocc, 1-й запуск | 398,2 с. |
| nocc, 2-й, 3-й и другие запуски | 72,6 с. |
Практически все наши кейсы соответствуют последней строчке, так как серваки запущены всегда, и чаще всего нам нужно докомпилировать небольшие изменения. То есть в большинстве случае имеем ускорение относительно оригинального distcc почти в 150 раз! И даже в менее экстремальном случае экономим минимум половину времени.
А ещё — то, что уже говорили:
* скорость не зависит от build-агента;
* быстрая пересборка при переключении веток;
* быстрая пересборка мастера после мержа.
Обращу внимание, что это замеры лишь компиляции кучи *.cpp* *→* *.o*. Линковка сюда не входит. Так же, как и не входит другая локальная работа, которую nocc не ускоряет.
Скорее всего, в вашем случае профит будет не такой большой, но всё-таки будет. Например, если скомпилировать из исходников clang-компилятор через CMake, получаем ускорение только в 1,5 раза относительно distcc на полном цикле. Почему так мало? Потому что процесс выглядит как «быстрая компиляция, долгая линковка, быстрая компиляция, долгая линковка». Если вычесть время линковки, то ускорение будет, как и ожидается, очень приличным. Но там линковка занимает почти всё время. У KPHP-сборки просто более высокая степень параллелизма, без промежуточных этапов, так уж мы устроены.
Выводы
------
Да какие особо выводы? Хорошая, рабочая штука. Быстрая, потому что демон, потому что `#include` ищем без препроцессора. По факту, это очень умный remote cache с уклоном в С++. Нам экономит очень много вычислительных ресурсов и времени на сборку. Webpack собирает js-ки в 10 раз дольше, чем KPHP + nocc — миллионы строк кода.
Если вы используете distcc, попробуйте nocc. Вероятно, заработает, если нет макросов внутри инклудов. Кто хочет, почитайте [обо всём на GitHub](https://github.com/VKCOM/nocc/blob/master/docs/architecture.md). И звёздочку поставьте :)
Кстати, на прошлом HighLoad++ я выступал с докладом, где рассказывал про всё это. Посмотреть его можно по ссылке ниже.
**Полезные ресурсы**
* [Видео с HighLoad++: «Как скомпилировать 200 000 файлов быстрее, чем distcc»](https://www.youtube.com/watch?v=8v0HOMrGixY).
* [nocc — распределённый компилятор для больших проектов на C++](https://github.com/VKCOM/nocc).
* [KPHP — наш компилятор](https://github.com/VKCOM/kphp).
* [Чат в телеграме — KPHP (Unofficial)](https://t.me/kphp_chat). Здесь можно задавать любые вопросы. | https://habr.com/ru/post/694536/ | null | ru | null |
# Распознаем повышение привилегий в ABBYY FineReader
Цикл о том, как я нахожу уязвимости повышений привилегий в Windows приложениях, продолжается. В предыдущих сериях: Steam ([CVE-2019-14743](https://habr.com/ru/company/pm/blog/462479/), [CVE-2019-15316](https://habr.com/ru/company/pm/blog/464367/), [CVE-2019-17180](https://habr.com/ru/company/pm/blog/469507/)) и Origin ([CVE-2019-19247, CVE-2019-19248](https://habr.com/ru/company/pm/blog/479704/)). Но сегодня речь пойдет не об игровом лаунчере, а о прикладном программном комплексе ABBYY FinerReader.
Краткое содержание – я расскажу, как благодаря компоненту, проверяющему лицензию, за 10 минут можно поднять свои права с уровня пользователя до NT AUTHORITY\SYSTEM. Данной уязвимости был присвоен идентификатор CVE-2019-20383, [ссылка на сайт ABBYY](https://support.abbyy.com/hc/ru/articles/360008536920-%D0%98%D1%81%D1%82%D0%BE%D1%80%D0%B8%D1%8F-%D0%B2%D0%B5%D1%80%D1%81%D0%B8%D0%B9-FineReader-15).
Разведка
--------
Я скачал с сайта ABBYY пробную версию FineReader и быстро проверил ее на предмет того, а есть ли вообще смысл ковырять продукт на предмет повышения привилегий. Да, в состав продукта входит сервис, который, судя по названию «ABBYY network license server», связан с лицензиями и по-умолчанию запущен от пользователя NT AUTHORITY\SYSTEM. Я запустил ProcMon начал смотреть поведение сервиса.
Мое внимание привлек файл, расположенный по пути «C:\ProgramData\ABBYY\FineReader\15\Licenses\Licensing.cnt». Сервис что-то из него читает, что-то в него пишет, в общем файл выглядел интересным кандидатом для опытов. Рассмотрим папку «C:\ProgramData\ABBYY\FineReader\15\Licenses». Для данной папки действует наследованный ACL «Все-Полный доступ» от родительской папки («C:\ProgramData\ABBYY\FineReader\15»), а значит можно удалить все ее содержимое, включая файл «Licensing.cnt».
Сервис, обнаружив отсутствие файла, попытался его создать, причем немного странным образом. Он создал файл вида «tmpXXXX-YYYYYYYYY.tmp», записал в него какие-то данные, а затем переименовал его в «Licensing.cnt».
Вот лог ProcMon в котором эта операция выполняется дважды.
Сначала она происходит в 20:36, а затем в 20:46. Между этими временными отметками файл снова был удален, чтобы быть созданным снова.
Прямоугольником 1 обозначена ситуация, когда сервис обнаружил отсутствие файла. Прямоугольник 2 – создание временного файла. Прямоугольник 3 – переименование временного файла. Прямоугольник 4 – повторение операций через 10 минут.
Рассмотрим формат имени «tmpXXXX\_YYYYYYYYY.tmp». В рамках одного запущенного процесса XXXX будет всегда постоянным, более того, на самом деле это идентификатор треда, который выполняет данные работы. YYYYYYYYY не остается постоянным, но если посмотрим на два соседних запуска (значения: 430210515 и 430810515), то появляется предположение, что это просто некоторая временная метка – разница между числами 600000 – удивительным образом совпадает с 10 минутами разницы. Еще несколько тестов подтверждают наше предположение.
Подведем итог этой части. Любой пользователь может удалить файл «C:\ProgramData\ABBYY\FineReader\15\Licenses\Licensing.cnt», далее он может в цикле очень часто запрашивать содержимое папки «C:\ProgramData\ABBYY\FineReader\15\Licenses» и в некоторый момент обнаружить там файл с именем «tmpXXXX\_YYYYYYYYY.tmp». Теперь пользователь будет подготовлен, после удаления файла он точно будет знать, в какой момент и с каким именем будет создан файл в следующий раз.
Теперь мы поиграем с симлинками
-------------------------------
**Как создавать симлинки без прав администратора**В общем случае, для создания симлинка с одного файла на другой необходимы права администратора. Но эту необходимость можно обойти. Рассмотрим, например, создание симлинка с файла «C:\abc\1» на файл «C:\def\2».
Сначала создадим NTFS reparse point (другое название NTFS mount point) с папки «C:\abc» на «\RPC Control\". «\RPC Control\» – это не обычная папка в привычном нам понимании, ее нельзя посмотреть, например, в эксплорере. Это системная объектная директория, внутри которой находятся, например, именованные мьютексы, события и прочие подобные объекты. Почему для нее работает перенаправление через NTFS reparse point непонятно, скорее всего, дело в использовании одинаковых абстракций для папок в файловой системе и объектных директорий. Для создания репарс-поинта необходимо, чтобы папка-источник была пустой и были права на запись в эту папку у пользователя.
Из объектной директории можно создать симлинк на файл без прав администратора. Создадим симлинк вида "\RPC Control\1" <-> «C:\def\2». В итоге, при обращении к файлу «C:\abc\1», все действия будут перенаправлены на файл «C:\def\2».
Изначально процесс создания файла-лицензии выглядит так:
Когда мы знаем точный момент следующей такой операции, мы можем создать следующие симлинки (имя исходной папки «C:\ProgramData\ABBYY\FineReader\15\Licenses\» пропустим):
`tmpXXXX_YYYYYYYYA.tmp <-> C:\test\l1\proxy
tmpXXXX_YYYYYYYYB.tmp <-> C:\test\l1\proxy
tmpXXXX_YYYYYYYYC.tmp <-> C:\test\l1\proxy
…
tmpXXXX_YYYYYYYYZ.tmp <-> C:\test\l1\proxy`
Где YYYYYYYYA, YYYYYYYYB, YYYYYYYYC, … YYYYYYYYZ – это различные временные метки в районе YYYYYYYYY+10минут (на случай, если временная метка слегка запоздает).
Далее создадим линк:
`C:\test\l1\proxy <-> C:\test\l2\nope`
Обратите внимание, что реально ни одного из этих файлов не существует. Это нужно, чтобы при обращении, например, к tmpXXXX\_YYYYYYYYB.tmp, произошло два перенаправления и в результате сервис работал с файлом «C:\test\l2\nope».
Как только мы обнаружим создание файла «C:\test\l2\nope», тут же следует создать два новых симлинка:
`C:\test\l1\proxy <-> C:\test\l2\payload
Licensing.cnt <-> C:\target\path`
Сервис продолжит писать содержимое файла в «C:\test\l2\nope», но переименование будет производить, уже пройдя по новому симлинку. Таким образом, вместо переименования, например, «tmpXXXX\_YYYYYYYYC.tmp» в «Licensing.cnt», реально будет переименован (перемещен) «C:\test\l2\payload» в «C:\target\path». Фактически **мы можем разместить файл с любым содержимым по любому пути от имени пользователя NT AUTHORITY\SYSTEM**.
Схематично это будет выглядеть так:
Цветом отмечено то, что реально будет выполняться из-за влияния симлинков.
Поднять привилегии, используя полученный примитив, уже легко – можно подложить свою dll к системным процессам и прочие подобные вещи. На этом этапе я обратился к представителям ABBYY и передал им информацию об уязвимости.
На данный момент, согласно ABBYY, уязвимость закрыта.
Timeline
--------
**25.11.2019** — обнаружение уязвимости
**26.11.2019** — запросил у производителя security-контакт
**26.11.2019** — отправка отчета об уязвимости производителю
**09.12.2019** — уязвимость подтверждена производителем
**10.01.2020** — уязвимость исправлена
**22.01.2020** — уязвимости присвоен CVE-2019-20383
**19.02.2020** — публикация данной статьи
Проектов сейчас много и мы расширяем команду «Перспективного мониторинга». Мы ищем специалистов по исследованию исходных кодов, а также экспертов в анализе мобильных приложений. Хотите присоединиться к моей команде — пишите мне, Анастасии ([Ana2121](https://habr.com/ru/users/ana2121/)) или на почту info@amonitoring.ru
[This article in english.](https://amonitoring.ru/article/abbyy-lpe/) | https://habr.com/ru/post/488826/ | null | ru | null |
# Android O: особенности поддержки новой операционной системы
Всем привет! Совсем скоро состоится важное событие – выход Android O. Поддержка новых версий операционной системы – обязанность любого серьезного продукта. Каждое обновление Android заставляет многих разработчиков серьезно поработать для сохранения работоспособности имеющихся функций и привнесения нового благодаря возможностям новых версий Android.
В данной статье мы рассмотрим основные изменения Android O и оценим их возможное влияние.
Работая над Android O, разработчики Google в первую очередь решали проблему быстрого расхода заряда аккумулятора на Android-устройствах, поэтому основные изменения связаны с оптимизацией фоновых задач и расхода ресурсов приложения.
Изменения в Android O можно разделить на две категории:
1. Потенциально «ломающие» текущую работоспособность и требующие дополнительных усилий для поддержки;
| Угроза | Target >= O | Target < O | Эффект |
| --- | --- | --- | --- |
| Background Location Limits | Affected | Affected | Ограничение на запрос геолокации |
| Background Execution Limits | Affected | OK | Изменение списка доступных бродкастов в манифесте;
Изменение времени работы сервисов в фоне. |
| Notification Channels | Affected | OK | Доработки для каналов нотификаций |
| WindowManager | Affected | OK | Влияние на работу перекрывающих окон |
| Privacy (Build.Serial/net.dns/e.t.c.) | Affected | Affected | Изменение доступности пользовательских идентификаторов |
| AccountManager.
getAccounts() | Affected | OK | Запрос списка аккаунтов на устройстве возвращает null |
2. Возможности для реализации новых функций.
| Новые возможности | Применение |
| --- | --- |
| Android Enterprise | Улучшение контроля над девайсом |
| Autofill Framework | Автозаполнение полей ввода |
| Notification Channels | Улучшение UX |
| Picture in Picture | Улучшение UX |
| Adaptive Icon | Консистентность с прошивкой вендора |
| Accessibility button and fingerprint gestures | Улучшение UX (accessibility кнопка в navigation bar, отлавливание жестов по сканеру отпечатка пальцев) |
| Webview Apis (напр., Safebrowsing) | Улучшение встроенных возможностей Webview |
| Pinning shortcuts and Widgets | Программное создание ярлыков и виджетов в лаунчере |
На наш взгляд это наиболее значимые (по крайней мере для «Лаборатории Касперского») изменения в Android O. Рассмотрим каждое по отдельности.
### Background Location Limits
Это ограничение на количество запросов местоположения для приложений, находящихся в фоне. Так, начиная с Android O и независимо от установленного TargetSDK, приложения смогут получать всего несколько обновлений местоположения в час. При этом, эти ограничения не распространяются на приложения, для которых справедлив хотя бы один из следующих параметров:
* Приложение не в фоне (запущено Activity, которое находится в состоянии Started или Paused);
* Приложение имеет активный Foreground-сервис;
* Другое Foreground-приложение имеет соединение с текущим (как через bind service, так и через content provider).
Таким образом, для Foreground-приложений поведение будет таким же, как и на предыдущих версиях Android.
В случае, если foreground service отсутствует, то запрос геолокации будет изменен:
* Fused Location Provider (FLP)
+ Для Background-приложений система будет определять новое местоположение только несколько раз в час, даже если приложение явно запросило больше обновлений
+ Для Foreground-приложений логика работы останется без изменений
* Geofencing
+ Background-приложения смогут получать обновления от geofencing-api чаще, чем обновления от Fused Location Provider
* GNSS Measurements and GNSS Navigation Message
+ Для приложений, находящихся в фоне не будут приходить обновления для сервисов GnssMeasurement и GnssNavigationMessage
* Location Manager
+ Для Background-приложений система будет определять новое местоположение только несколько раз в час
### Background execution limits
Ограничение на фоновую работу приложения – ключевое изменение Android O, которое будет заметно в большой степени лишь при переходе на targetSdk “O”. В случае, если targetSdk <= 25, то если приложение находится в фоне и было переведено системой в Cached-состояние (когда система может свободно убить процесс в любой момент), и при этом оно не имеет активных компонентов, система отпустит все WakeLock (индикатор, что приложение не должно быть в состоянии сна) этого приложения. Важно отметить, что в случае, если приложение не targetSDK < O, то в настройках можно выставить политику поведения такую же, как если бы приложение было бы с targetSDK O.
Для приложений с targetSdk “O” background execution limits состоят из двух категорий:
1. **Ограничение фоновых сервисов**
После того как приложение перешло в background, у него есть «окно» в несколько минут, в течение которого сервисы могут запускаться и работать. После истечения этого интервала все сервисы останавливаются, а запуск новых будет приводить к падению приложения. Google старается минимизировать количество работающих фоновых сервисов и предлагает использовать JobScheduler и GcmNetworkManager.
В случае если необходимо выполнять длительные задачи в фоне, рекомендуется использовать foregroundService, который будет явно говорить пользователю, что приложение работает.
Стоит обратить внимание, что после того как вызвали `Context.startForegroundService()` необходимо в течение 5 секунд вызвать `startForeground()`, в противном случае система может показать ANR.
2. **Ограничений на регистрацию broadcasts в манифесте**
Новая версия Android продолжает дело, начатое Android 7.0 (наверняка все помнят приложения, которые переподнимались при каждой смене мобильной станции). Но если в 7-ой версии в манифесте нельзя было зарегистрировать всего лишь несколько бродкастов, то теперь таких бродкастов стало большинство.
### Notification Channels
Notification Channels — инструмент для группировки нотификаций в тематические группы, которыми пользователь сможет управлять напрямую. Если приложение собрано с target >= O, тогда необходимо поддержать хотя бы один из каналов нотификаций. В случае, если targetApi < O, тогда работа с нотификациями внутри продукта останется прежней.
### WindowManager
В Android O вводится новый тип окон (для targetSDK O), которые могут быть выведены поверх других окон – TYPE\_APPLICATION\_OVERLAY. При этом несколько старых типов окон стали **deprecated**, и теперь при их использовании генерируется **RuntimeException**.
Эти типы окон теперь могут использоваться только системными приложениями:
* [TYPE\_PHONE](https://developer.android.com/reference/android/view/WindowManager.LayoutParams.html#TYPE_PHONE)
* [TYPE\_PRIORITY\_PHONE](https://developer.android.com/reference/android/view/WindowManager.LayoutParams.html#TYPE_PRIORITY_PHONE)
* [TYPE\_SYSTEM\_ALERT](https://developer.android.com/reference/android/view/WindowManager.LayoutParams.html#TYPE_SYSTEM_ALERT)
* [TYPE\_SYSTEM\_OVERLAY](https://developer.android.com/reference/android/view/WindowManager.LayoutParams.html#TYPE_SYSTEM_OVERLAY)
* [TYPE\_SYSTEM\_ERROR](https://developer.android.com/reference/android/view/WindowManager.LayoutParams.html#TYPE_SYSTEM_ERROR)
### Privacy (Build.Serial/net.dns/e.t.c.)
В Android O появляются некоторые улучшения, призванные помочь пользователю управлять доступом к своим идентификаторам. Эти улучшения включают:
* Ограничение на использование постоянных (не сбрасываемых) устройство-зависимых идентификаторов
* Обновление системой Wi-Fi стека, связанного с изменениями прошивки Wi-Fi-чипсета на устройствах типа Pixel, Pixel XL и Nexus 5x для рандомизации MACадресов во время сканирований сетей
* Обновление в механизме, при помощи которого приложения запрашивали информацию об учётной записи и предоставление большего контроля над данными пользователя
### AccountManager.getAccounts()
Начиная с Android O, разрешения GET\_ACCOUNTS недостаточно для получения доступа к списку учетных записей. Теперь существует два варианта для приложений с targetSDK O:
* Использовать `AccountManager.newChooseAccountIntent()`.
* Использовать метод, определяемый аутентификатором, для доступа к учетной записи.
### Android Enterprise
Google активно развивает Android for Work. В Android O они предоставили больше возможностей для контроля устройства. Например, для рабочего профиля можно заводить отдельную блокировку со своими настройками, узнавать информацию о доступных обновлениях системы.
### Autofill Framework
C появлением Autofill Framework API появилась возможность более удобного заполнения пользовательских данных в приложения, чем при использовании Accessability. При вызове фреймворка нужно будет сопоставить packageName продукта, для которого произошел вызов на автозаполнение, после чего предоставить данные для ввода. Для верной идентификации полей логина и пароля нужно создать и поддерживать базу с resourceId контролов или другой служебной информацией, позволяющей верно идентифицировать UI-элементы для автозаполнения.
### Picture in Picture
Android O позволяет запускать активности в режиме Picture-In-Picture, который является специальным типом multi-window mode. Google рекомендует использовать данный режим исключительно для приложений, отображающих видео.
### Adaptive Icon
Начиная с Android O для приложения можно предоставить еще один вариант **Launcher Icon**, который система сможет по маске легко обрезать до формы, которая используется производителем устройства. Также при наличии такой иконки система сможет делать некоторые анимации иконок приложений.
### Pinning shortcuts and Widgets
Новая возможность Android O — программное создание ярлыков и виждетов в лаунчере. Ярлык представляет собой отдельную иконку, позволяющую по клику выполнить задачу в приложении по заданному интенту. Для успешного прикрепления виджета или ярлыка требуется согласие пользователя в системном диалоге-подтверждении.
### Вывод
Время, когда Android позволял делать все что угодно, уходят в прошлое. Android расширяет «легальные» инструменты для создания новых функций, закрывает бреши для хаков и заставляет работать честно. Android O ломает часть существующих приложений, но старается сделать конечных пользователей счастливее. Ура, спасибо!
Желаю всем писать хорошие приложения, думать о пользователях и быть счастливыми владельцами Android-устройств.
**P.S.**
Автор статьи — Александр Шиндин [ayushindin](https://habrahabr.ru/users/ayushindin/).
Саша написал статью и смело заболел, поэтому доверил выложить статью на Хабр мне =)
Пожелаем ему скорейшего выздоравления! | https://habr.com/ru/post/334652/ | null | ru | null |
# Простой чат с помощью Channel API на Google App Engine для Python
*Представляю вашему вниманию вольный перевод статьи под названием "[A Simple Chat using the Channel API](http://netgamix.wordpress.com/2011/02/15/a-simple-chat-using-the-channel-api/)". Так же я решил немного добавить своего кода.*
Сегодня мы представляем вам новую статью для [Google App Engine](http://code.google.com/appengine/) посвященную Сhannel API, которое появилось в декабре 2010 года в релизе 1.4. С этого момента стала возможной отправка сообщений напрямую с сервера клиенту и обратно без использования [polling](http://en.wikipedia.org/wiki/Polling_%28computer_science%29).
Поэтому стало достаточно просто реализовать чат на Google App Engine. Процесс реализации описан под катом.
Вы можете посмотреть **демо** по адресу <http://chat-channelapi.appspot.com/>.
**Код проекта** можно скачать [здесь](https://github.com/Limfocit/Chat-channelapi)(код из ориганальной статьи лежит [здесь](https://github.com/raulsann/SimpleChatUsingTheChannelAPI)).
В нашем приложении, чтобы создать канал между пользователем и программой надо сделать следующие шаги, приведенные ниже на картинке.
Шаги:
1) Приложение создает id канала(channel id) и токен и отправляет их клиенту
2) Клиент использует токен, чтобы открыть сокет, который будет слушать канал
3) Клиент 2 отправляет сообщение для чата в приложение, вместе с его уникальным id канала
4) Приложение отправляет сообщение всем клиентам, которые слушают канал через сокет. Для этого используется id канала каждого клиента.
Прежде чем удут описаны все шаги, следует отметить, что мы упростили максимально сущности(entity) базы данных, которые будут принимать участие в программе. Мы создали две — модель User и Message.
> `**class** **OnlineUser**(db.Model):
>
> nick=db.StringProperty(default="")
>
> channel_id=db.StringProperty(default="")
>
>
>
> **class** **Message**(db.Model):
>
> text=db.StringProperty(default="")
>
> user=db.ReferenceProperty(User)`
В коде также используется механизм сессий, реализованный в библиотеке [GAE utilities](http://gaeutilities.appspot.com/). Но не обращайте много внимания на сессии.
**Шаг 1.**
В этом шаге наше приложение для чата создает id канала и токен и отправляет их клиенту. Код этого шага достаточно прост. Только не забудьте импортировать Channel API:
> `**from** **google.appengine.api** **import** channel`
После этого создайте обработчик(handler), который генерирует уникальный id каждому пользователю(мы воспользуемся функцией uuid4() из модуля uuid). Ниже приведенный обработчик как раз это делает и передает данные в шаблон клиенту:
> `**class** **ChatHandler**(webapp.RequestHandler):
>
> **def** get(self):
>
> self.redirect('/')
>
>
>
> **def** post(self):
>
> *# сессия из библиотеки http://gaeutilities.appspot.com/*
>
> self.session = Session()
>
> *# получаем ник*
>
> nick = self.request.get('nick')
>
> **if** **not** nick:
>
> self.redirect('/')
>
> *# проверяем, не существует ли пользователя с таким ником*
>
> user = OnlineUser.all().filter('nick =', nick).get()
>
> **if** user:
>
> self.session['error']='That nickname is taken'
>
> self.redirect('/')
>
> **return**
>
> **else**:
>
> self.session['error']=''
>
> *# генерируем уникальный id канала для Channel API*
>
> channel_id=str(uuid.uuid4())
>
> chat_token = channel.create_channel(channel_id)
>
> *# сохраняем пользователя*
>
> user = OnlineUser(nick=nick,channel_id=channel_id)
>
> user.put()
>
> *# получаем последние 100 сообщений*
>
> messages=Message.all().order('date').fetch(1000)
>
> *# генерируем шаблон и отправляем его в качестве ответа клиенту*
>
> template_vars={'nick':nick,'messages':messages,'channel\_id':channel_id,'chat\_token':chat_token}
>
> temp = os.path.join(os.path.dirname(__file__),'templates/chat.html')
>
> outstr = template.render(temp, template_vars)
>
> self.response.out.write(outstr)`
Чтобы не перегружать данную статью, я не привожу здесь код шаблона. Его вы можете посмотреть в github.
**Шаг 2**
Теперь клиент отвечает за извлечение токена и открытие сокета. Мы используем jQuery для уменьшения кода javascript. Ниже приведен наш код:
> `**var** chat_token = $('#channel\_api\_params').attr('chat\_token');
>
> **var** channel = **new** goog.appengine.Channel(chat_token);
>
> **var** socket = channel.open();
>
> socket.onopen = **function**(){
>
> };
>
> socket.onmessage = **function**(m){
>
> **var** data = $.parseJSON(m.data);
>
> $('#center').append(data['html']);
>
> $('#center').animate({scrollTop: $("#center").attr("scrollHeight")}, 500);
>
> };
>
> socket.onerror = **function**(err){
>
> alert("Error => "+err.description);
>
> };
>
> socket.onclose = **function**(){
>
> alert("channel closed");
>
> };`
**Шаг 3**
На этом шаге Клиент 2 отправляет сообщение в наш чат через интерфейс. Для этого надо только сделать текстовое поле и кнопку отправки сообщения. Сообщение будет отправляться javascript кодом с помощью простого слушателя(listener), которого мы реализуем с помощью jQuery. Вы можете использовать вместо этого любую javsctipt библиотеку или просто с помощью объекта XMLHttpRequest. Только учтите, что обязательно посылать уникальный id канала клиента, чтобы верно идентифицировать клиента в приложении.
> `$('#send').click(**function**(){
>
> **var** text = $('#text').val();
>
> **var** nick = $('#nick').attr('value');
>
> **var** channel_id = $('#channel\_api\_params').attr('channel\_id');
>
> $.ajax({
>
> url: '/newMessage/',
>
> type: 'POST',
>
> data:{
>
> text:text,
>
> nick:nick,
>
> channel_id:channel_id,
>
> },
>
> success: **function**(data){
>
> },
>
> complete:**function**(){
>
> }
>
> });
>
> });`
**Шаг 4**
Чтобы получать сообщения от клиентов, нам надо реализовать новый обработчик, который так же будет отправлять сообщение всем клиентам.
> `**class** **NewMessageHandler**(webapp.RequestHandler):
>
> **def** post(self):
>
> *# получаем параметры*
>
> text = self.request.get('text')
>
> channel_id = self.request.get('channel\_id')
>
> q = db.GqlQuery("SELECT \* FROM OnlineUser WHERE channel\_id = :1", channel_id)
>
> nick = q.fetch(1)[0].nick
>
> date = datetime.datetime.now()
>
> *# сохраняем сообщение*
>
> message=Message(user=nick,text=strip_tags(text), date = date, date_string = date.strftime("%H:%M:%S"))
>
> message.put()
>
> *# генерируем шаблон сообщения*
>
> messages=[message]
>
> template_vars={'messages':messages}
>
> temp = os.path.join(os.path.dirname(__file__),'templates/messages.html')
>
> outstr = template.render(temp, template_vars)
>
> channel_msg = json.dumps({'success':True,"html":outstr})
>
> *# отправляем всем клиентам сообщение*
>
> users = OnlineUser.all().fetch(100)
>
> **for** user **in** users:
>
> channel.send_message(user.channel_id, channel_msg)`
**Дополлнительный шаг**
На данном этапе заканчивается исходная статья, но мне захотелось внести несколько изменений в код, связанные со следующей задачей. В исходной статье имена пользователей блокируются после входа в чат и уже под этим ником нельзя войти. Уберем данное ограничение. Для этого надо удалять после завершения действия ключа данные пользователя из базы данных. Ключ перестает действовать либо пока не пройдет два часа, либо пока клиент не вызовет функцию close() у сокета. После чего вызывается обработчик, зарегистрированный по адресу /\_ah/channel/disconnected/. Напишем такой обработчик.
> `**class** **ChannelDisconnectHandler**(webapp.RequestHandler):
>
> **def** post(self):
>
> channel_id = self.request.get('from')
>
> q = OnlineUser.all().filter('channel\_id =', channel_id)
>
> users = q.fetch(1000)
>
> db.delete(users)`
В javascript код добавим обработку события, которое возникает при уходе пользователя с данной страницы:
> `$(window).unload(**function** (){
>
> socket.close();
>
> });`
Осталось обработать следующую ситуацию. Если пользователь вошел в чат, но достаточно быстро закрыл окно, то не происходит открытие канала. Это приводит к ситуации, что запись о пользователе есть в базе, но она не удаляется из-за того, что не закрывается канал. Изменим нашу модель данных пользователя:
> `**class** **OnlineUser**(db.Model):
>
> nick=db.StringProperty(default="")
>
> channel_id=db.StringProperty(default="")
>
> creation_date=db.DateTimeProperty(auto_now_add=True)
>
> opened_socket=db.BooleanProperty(default=False)`
Теперь у нас есть время создания записи(creation\_date) и информация о том, пришло ли подтверждение со стороны клиента об открытии канала(opened\_socket). При открытии канала со стороны клиента с помощью вызова channel.open() на стороне сервера вызывается обработчик, зарегистрированный по адресу /\_ah/channel/connected/. Этот обработчик будет выставлять у пользователя подтверждение открытия канала:
> `**class** **ChannelConnectHandler**(webapp.RequestHandler):
>
> **def** post(self):
>
> channel_id = self.request.get('from')
>
> q = OnlineUser.all().filter('channel\_id =', channel_id)
>
> user = q.fetch(1)[0]
>
> user.opened_socket = True
>
> user.put()`
Данный код отправляет серверу id канала для идентификации. Обработчик представлен ниже:
> `**class** **RegisterOpenSocketHandler**(webapp.RequestHandler):
>
> **def** post(self):
>
> channel_id = self.request.get('channel\_id')
>
> q = OnlineUser.all().filter('channel\_id =', channel_id)
>
> user = q.fetch(1)[0]
>
> user.opened_socket = True
>
> user.put()`
Последним этапом будет запуск c помощью сron-а обработчика, который будет выделять все записи из модели пользователей OnlineUser, у которых yе будет подтверждения открытия канала и время создание от текущего будет больше 120 секунд:
> `**class** **ClearDBHandler**(webapp.RequestHandler):
>
> **def** get(self):
>
> q = OnlineUser.all().filter('opened\_socket =', False)
>
> users = q.fetch(1000)
>
> **for** user **in** users:
>
> **if** ((datetime.datetime.now() - user.creation_date).seconds > 120):
>
> db.delete(user)`
**В итоге**
Нам удалось построить простое приложение для чата. Четырех шагов из исходной статьи достаточно, чтобы показать Channel API, добавление в код было сделано чтобы приложение выглядело, на мой взгляд, более законченным.
**P.S.**Реальная работа приложения показала, что надо фильтровать сообщения, исключая из них html тэги. Для этого импортируем функцию strip\_tags из фреймворка django:
> `**from** **django.utils.html** **import** strip_tags`
В обработчике новых сообщений(NewMessageHandler) заменим код создания нового сообщения на следующий:
> `message=Message(user=nick,text=strip_tags(text), date = date, date_string = date.strftime("%H:%M:%S"))` | https://habr.com/ru/post/126009/ | null | ru | null |
# Ускоряем векторизацию и обращения к памяти в DL_MESO: примеры оптимизации с Vectorization Advisor на большом проекте
Мы уже писали [про Vectorization Advisor](http://habrahabr.ru/company/intel/blog/255731/) и примеры его применения [на простых сэмплах](http://habrahabr.ru/company/intel/blog/257309/). Сегодня поделимся информацией том, как инженеры Intel совместно с исследователями из STFC Daresbury Laboratory в Великобритании оптимизировали пакет DL\_MESO.
[DL\_MESO](http://www.scd.stfc.ac.uk/40694.aspx) – научный пакет для симуляции конденсированных сред на мезоскопическом уровне (да простят меня химики и физики, если не совсем корректно перевёл). Пакет разработан в лаборатории Дарсбери и широко применяется как в исследовательском сообществе, так и в индустрии (компаниями Unilever, Syngenta, Infineum). С помощью этого ПО ищутся оптимальные формулы для шампуней, удобрений и топливных присадок. Этот процесс называют “Computer Aided Formulation” (CAF) – я перевёл как «САПР в области разработки химических формул».
Симуляция CAF – очень ресурсоёмкие вычисления, поэтому разработчики были сразу заинтересованы в максимально производительном дизайне. И DL\_MESO был выбран одним из совместных проектов в “Intel Parallel Computing Center” (IPCC) между Intel и Hartree.
Разработчики DL\_MESO хотели воспользоваться аппаратными возможностями векторного параллелизма, ведь грядущие технологии вроде AVX-512 потенциально могут сделать код в 8 раз быстрее на числах с двойной точностью (по сравнению с не векторизованным кодом).
В этом посте мы расскажем, как учёные из Дарсбери использовали Vectorization Advisor для анализа кода Lattice Boltzmann Equation в DL\_MESO, какие конкретно проблемы они нашли, и как исправили свой код, чтобы разогнать его в 2.5 раза.
Профиль Survey
==============
Что такое Vectorization Advisor, читайте в [первой статье](http://habrahabr.ru/company/intel/blog/255731/). Здесь перейдём сразу к профилю Survey компонента Lattice Boltzman. Около половины всего времени исполнения приходится на десять «горячих» циклов, среди которых нет явных лидеров, каждый тратит не более 12% общего времени программы. Эта картина близка к «плоскому профилю» (flat profile), что обычно плохо для программиста. Ведь для достижения заметного ускорения, придётся оптимизировать каждый из циклов в отдельности.
Но, к счастью для разработчиков из Дарсбери, Vectorization Advisor может быстро охарактеризовать циклы следующим образом:
1. **Векторизуемые**, но **не векторизованные** циклы, которые требуют минимальных изменений кода (обычно используя OpenMP4.x) для включения генерации SIMD кода. Первые 4 цикла (по времени ЦПУ) попадают в эту категорию.
2. **Векторизованные** циклы, производительность которых может быть улучшена простыми манипуляциями.
3. **Векторизованные** циклы, производительность которых ограничена структурой расположения данных. Оптимизация таких циклов требует более серьёзной переработки кода. Как мы увидим позже, после устранения проблем с первыми двумя категориями, двумя самыми нагруженными циклами станут именно такие.
4. Векторизованные циклы, которые уже работают хорошо.
5. Все другие случаи (включая не векторизуемые циклы).
Vectorization Advisor не только выдаёт информацию по циклам. Вкладки Recommendations и Compiler Diagnostic Details позволяют узнать о специфичных проблемах и путях их решения.
В нашем случае, третий хотспот («горячий» цикл, да простят меня блюстители чистоты языка) в fGetSpeedSite не смог векторизоваться, потому что компилятор не смог оценить, сколько в нём будет итераций. Compiler Diagnostic Details описывает суть проблемы с примером и предложениями по её решению – добавить директиву «#pragma loop count». Следуя совету, данный цикл был быстро векторизован и переместился из категории 2 в категорию 4.
Даже когда код может быть векторизован, это не обязательно сразу ведёт к росту производительности (категории 2 и 3). Поэтому важно исследовать уже векторизованные циклы на предмет их эффективности.
Простая оптимизация: padding в вычислительном ядре “equilibrium distribution”
=============================================================================
```
int fGetEquilibriumF(double *feq, double *v, double rho)
{
double modv = v[0]*v[0] + v[1]*v[1] + v[2]*v[2];
double uv;
for(int i=0; i
```
Массив lbv хранит скорости для пространственной решётки по всех измерениях. Переменная lbsy.nq содержит количество скоростей. Модель представляет трёхмерную 19-скоростную решётку (схема D3Q19). Т.е. значение lbsy.nq равно 19. Результирующее равновесие хранится в массиве feq[i].
При первом анализе цикл был скалярным, не векторизованным. Простым добавлением "#pragma omp simd" перед циклом, он был векторизован, и его доля в общем времени ЦПУ упала с 13% до 9%. Но даже с этими изменениями, здесь ещё есть возможности для улучшений.
Новый результат Advisor XE показал, что компилятор сгенерировал не один, а два цикла:
* Векторизованное тело цикла с длинной вектора (Vector Length – VL) равным 4 – 4 числа типа double в 256-битном регистре AVX.
* Скалярный remainder, потребляющий 30% времени этого цикла.
Этот Скалярный remainder – ненужный накладной расход. Его наличие наносит ущерб параллельной эффективности. Такой большой «вес» remainder-а вызван тем, что количество итераций не делится на VL (длину вектора) ровно. Компилятор генерирует векторные инструкции для итераций 0-15, а оставшиеся итерации с 16 по 18 выполняются в скалярном remainder. 3 итерации, да ещё и медленно последовательно исполняющиеся, и составляют 30% времени выполнения цикла. В идеале все итерации должны быть исполнены в векторном коде, и remainder вообще не должно быть.
Мы может применить технику «подбивки» (data padding) к нашему циклу. Увеличим количество итераций до 20, что будет кратно VL (4). Advisor XE явно советует это сделать на вкладке Recommendations:
Чтобы «подбить» данные, нужно будет увеличить размеры массивов feq[], lbv[] и lbw[], чтобы не получить segmentation fault. В таблице в конце статьи показаны изменения в коде. Значение lbsy.nqpad является суммой оригинального количества итераций и значения padding (NQPAD\_COUNT).
Кроме того, разработчики DL\_MESO добавили директиву “#pragma loop count” перед циклом. Явно видя, что количество итераций кратно VL, компилятор генерирует векторный код, и remainder не исполняется.
В коде DL\_MESO есть много таких же конструкций, которые можно улучшить тем же способом. Мы исправили три другие цикла в том же исходном файле и получили 15% ускорения каждого из них.
Балансировка накладных расходов и компромиссы оптимизации
=========================================================
Техника подбивки, использованная для первых двух циклов, имеет свою цену:
* С точки зрения производительности, мы устраняем накладные расходы в скалярном remainder, но привносим дополнительные вычисления в векторную часть.
* С точки зрения поддержки кода, мы переделали аллокацию структур данных и потенциально внесли в директивы компилятора значения, зависящие от размера входных данных и типа нагрузки.
В нашем случае положительный эффект на производительность перевесил минусы, и усложнение кода было приемлемым.
Оптимизируем расположение данных: структуры массивов
====================================================
Векторизация, data padding и выравнивание данных улучшили производительность хотспота №1 на 25-30%, эффективность векторизации по оценке Advisor XE выросла до 56%.
Т.к. 56% всё ещё далековато от 100%, разработчики решили исследовать, что блокирует рост производительности. Посмотрев ещё раз на “Vector Issues/Recommendation”, они обнаружили новую проблему – “Possible inefficient memory access patterns present”. Соответствующая рекомендация советует запустить анализ “Memory Access Pattern” (MAP). Такой же совет был в колонке Traits:
Для запуска MAP анализа, разработчик отмечает нужные циклы и нажимает кнопку запуска MAP на панели Workflow.
Распределение страйдов в результате MAP показывает наличие unit-stride (последовательного доступа) и non-unit “constant” stride – обращений к памяти с постоянным шагом:
Данные MAP в исходном коде говорят о наличии обращений со страйдом 3 (для оригинальной скалярной версии) и страйдом 12 (для векторизованной версии с паддингом) при обращении к массиву lbv (см. таблицу в конце).
Обращение с шагом 3 происходит к элементам массива скоростей lbv. Каждая новая итерация смещается на 3 элемента массива. Откуда берётся 3 понятно из выражения lbv[i\*3+X], к которому аттрибутируются наши обращения к памяти.
Такой непоследовательный доступ не очень хорош для векторизации, потому что не даёт загрузить все элементы в векторный регистр за одну инструкцию типа mov («упакованный» её вариант называется иначе). Но обращения с постоянным шагом зачастую можно преобразовать в последовательный доступ, применив преобразование из «массива структур» в «структуру массивов». Заметим, что после MAP анализа окно рекомендаций советует именно это (AoS->SoA) для решения проблемы неэффективного обращения к памяти – см. скриншот выше.
Разработчики применили такое преобразование к массиву lbv. Для этого массив lbv, изначально содержащий скорости для X, Y и Z, разбили на три массива: lbvx, lbvy и lbvz.
Разработчики DL\_MESO говорят, что преобразование структуры массивов было трудозатратным по сравнению с паддингом, но результат оправдал усилия – цикл в fGetEquilibrium стал в 2 раза быстрее, и подобные улучшения случились ещё с несколькими циклами, работающими с массивом lbv.
Результаты трансформации структур данных и оптимизации циклов (padding, выравнивание), вместе с метриками эффективности и шаблонов доступа к памяти Advisor XE:
Эволюция исходного кода рассматриваемого цикла – директивы векторизации, выравнивание, паддинг, трансформация AoS -> SoA, вместе с результатами MAP из Advisor XE:
Резюме
======
С помощью анализа DL\_MESO в Vectorization Advisor и добавив в код несколько директив, удалось уменьшить время трёх самых горячих циклов на 10-19%. Все оптимизации основывались на рекомендациях Advisor-а. Была проделана работа по «включению» векторизации и улучшения производительности цикла с помощью «подбивки данных» (padding). Применив подобные техники к ещё нескольким циклам, было получено ускорение всего приложения на 18%.
Следующее серьёзное улучшение было получено при трансформации данных: «массива структур» в «структуру массивов». Опять же, исходя из рекомендации Advisor XE.
Кроме того, работа и тесты изначально проводились на серверах с процессорами Xeon (Advisor пока не работает на сопроцессоре). Когда то же самое было сделано для кода, работающего на сопроцессоре Xeon Phi, был получен примерно такой же выигрыш – заоптимизировали сопроцессор без дополнительных усилий.
Ниже продемонстрировано ускорение, полученное на обычном сервере (помечено AVX) и карте Xeon Phi (помечено KnC). На Xeon CPU ускорились в 2.5 раза, на Xeon Phi – в 4.1 раза:
Цитата разраобтчика DL\_MESO: “I'm already sold on this tool what we now need is a version for the Xeon Phi!” (Luke Mason, computational scientists in Daresbury lab).
*Этот пост является переводом статьи Захара Матвеева (Intel Corporation).* | https://habr.com/ru/post/266685/ | null | ru | null |
# Webmin — такой, каким мы все хотели бы его видеть
[*Webmin*](https://github.com/webmin/webmin) — это web-интерфейс для системного администрирования *Unix*. Кто из системных администраторов не знает об этом?
Также все знают, что проект *Webmin* был начат очень давно (около 15 лет назад), что наложило свой отпечаток на управление и интегрирование современных тем (оформлений) для панели. Часть современных модулей в *Webmin* управляются посредством библиотеки под названием `ui-lib.pl`, входящей в его дистрибутив, которая и обрабатывает поступающий на дальнейшее отображение модуль. Только вот проблема заключается в том, что множество из представленных модулей, в силу своей древности, вовсе не взаимодействуют с библиотекой упомянутой выше. Старые модули просто создавались каждый в отдельности, как получится. По словам разработчиков, проблему полного разделения `логики` и `презентации` планируется полностью устранить в версии *Webmin 2.0*, но это случится годами позже.
Сегодня создать идеальную тему оформления панели, соблюдая все современные правила и стандарты, крайне не просто. Поставив данную задачу перед собой, и потратив около 200 часов работы, в конечном счете, я получил результат, который оказался превосходящим все мои первоначальные ожидания.
#### **Презентация**
Для построение темы, которую я назвал [Authentic](https://github.com/qooob/authentic-theme) — *theme for Webmin/Usermin/Virtualmin/Cloudmin based on Bootstrap and Font Awesome that is made with love*. Изначально, я использовал [альфа-релиз](http://theme.winfuture.it/) на тот момент существовавшей темы, которая использовала *Bootstrap* и *Font Awesome*. Только тот самый альфа-релиз был не пригоден для каждодневного использования, в силу того, что работал только примерно с 10% всего контента панели управления. Плюс ко всему ошибки, допущенные при разработке предыдущими авторами, не позволяли в большей половине случаев даже сохранить изменения, поскольку форма попросту не содержала необходимых (потерянных) атрибутов.
Все это я исправил в своей работе, выпустив абсолютно рабочию и пригодную для ежедневного использования версию темы.
*[Authentic](https://github.com/qooob/authentic-theme)* работает под управлением последних версий *Bootstrap* и *jQuery*, использует *Font Awesome*, *CodeMirror* и несколько других современных плагинов.
#### **Принципы**
* Тема должна работать со всеми *Webmin/Usermin* модулями;
* Быть приятной, быстрой, легкой и простой в использовании;
* Быть совместима со всеми платформами и мобильными устройствами.
#### **Функциональная возможность (на момент версии 13.0.0)**
* Редактируемые настройки темы при использования интерфейса Webmin;
* Автодополнения при поиске в выборе меню, названию виртуальных серверов/машин;
* Горячие клавиши для быстрого переключения
* Уведомления по безопасности
* Расширенная поддержка для ConfigServer Security & Firewall, с дополнительно интегрированными функциями поиска и фильтрации;
* Выделение цветом кода, с номерами строк, при редактировании файлов конфигурации вручную;
* Возможность добавлять собственный логотип;
* Беспрецедентно одинаково удобная и полная навигация, как на Desktop, так и на Mobile версии.
#### **Как установить тему *Authentic*?**
Для получения инструкций по использованию темы просто посмотрите ЧаВО на моем репозитории на [GitHub](https://github.com/qooob/authentic-theme#faq), там все детально описано. Советую прочитать раздел про создание symlink для темы *Usermin* во избежание ненужной работы.
Для тех, кто просто хочет скачать и установить тему:
1. [Загрузите](https://rostovtsev.ru/.git/authentic-theme/authentic-theme-latest.wbt.gz) готовую тему;
2. Установите ее для *Webmin*, следуя в `Webmin->Webmin Configuration->Webmin Themes->Install themes->From uploaded file` или для *Usermin* следуя в `Webmin->Usermin Configuration->Usermin Themes->Install themes->From uploaded file`.
В случае если на сервере уже установлены модули *Virtualmin/Cloudmin*, то делать ничего не нужно, все просто будет работать.
Важной деталью является то, что для полноценной работы темы, нужны последние версии *Webmin/Usermin/Virtualmin/Cloudmin*. Минимальные требования для *Webmin* — версия 1.730, для *Usermin* — версия 1.640, для *Virtualmin* — версия 4.14, а для *Cloudmin* — версия 8.01.
Тема включена в официальный дистрибутив *Webmin* и ведется разговор о том, чтобы сделать **Authentic Theme** темой по умолчанию.
Всем спасибо за внимание. | https://habr.com/ru/post/237797/ | null | ru | null |
# Использование std::optional в С++17
Давайте возьмём пару от двух типов — что вы можете сделать с композицией подобного рода?
В этой статье я расскажу вам про `std::optional` — новый вспомогательный тип, добавленный в C++17. Это обёртка для вашего типа и флаг показывает, инициализировано ваше значение или нет. Давайте посмотрим, где это может быть полезно.
Вступление
----------
Добавлением логических флагов к другим типам вы можете достичь то, что называется "Nullable типы". Как было сказано ранее, флаг используется для обозначения того, доступно значение или нет. Такая обёртка выразительно представляет объект, который может быть пустым (не через комментарии :).
Вы можете достигнуть пустого значения объекта с помощью использования уникальных идентификаторов (-1, бесконечность, `nullptr`), но это не так точно выражает мысль, как отдельный тип-обёртка. Вы даже можете использовать `std::unique_ptr` и трактовать пустой указатель как неинициализированный объект — это сработает, но вместе с этим вы должны будете смириться с затратами на выделения памяти для объекта там, где в этом нет необходимости.
Опциональные типы — это то, что пришло из мира функционального программирования, принеся с собой безопасность типов и выразительность. Большинство других языков имеют что-то похожее: например `std::option` в `Rust`, `Optional` в `Java`, `Data.Maybe` в `Haskell`.
`std::optional` был добавлен в C++17 из `boost::optional`, где был доступен многие годы. Начиная с C++17, вы можете просто написать `#include` для использования этого типа.
Этот тип является типом-значением (value-type) (таким образом, вы можете копировать его). Более того, для `std::optional` не нужно отдельно выделять память.
`std::optional` является частью **словарных типов C++** на ряду с `std::any`, `std::variant` и `std::string_view`.
Использование
-------------
Обычно, опциональный тип может быть использован в следующих сценариях:
* Если вы хотите красиво представить nullable-тип.
+ Это лучше, чем использовать уникальные значения (например, `-1`, `nullptr`, `NO_VALUE` или что-то подобное).
+ Например, среднее имя пользователя является опциональным. Вы можете предположить, что пустой строки будет для этого достаточно, но может быть важно само понимание того, что пользователь что-то ввёл. С помощью `std::optional` вы сможете получить больше информации.
* Вернуть результат каких-либо вычислений, которые не смогли дать конечный результат, но это не является ошибкой.
+ Например, поиск элемента в словаре: если нет элемента, соответствующего заданному ключу, то это не ошибка, но нам стоит обработать эту ситуацию.
* Для получения ресурсов с отложенной загрузкой.
+ Например, если у какого-либо ресурса нет конструктора по умолчанию и конструирование объекта занимает довольно длительное время. Тогда вы можете объявить `std::optional`, и передать этот объект дальше системе, а выполнять загрузку уже позднее по необходимости.
* Чтобы передать опциональные параметры в функции.
Мне нравится определение опционального типа из `boost`, которое подводит итог по тем ситуациям, когда нам следует его использовать. [Из документации boost](https://www.boost.org/doc/libs/1_67_0/libs/optional/doc/html/boost_optional/tutorial/when_to_use_optional.html):
> Шаблонный класс std::optional управляет опциональным значением, т. е. значением, которое может быть представлено, а может и не быть.
>
> Обычным примером использования опционального типа данных является возвращаемое значение функции, которая может вернуть ошибочный результат в процессе выполнения. В отличии от других подходов, таких как std::pair, опциональный тип данных хорошо управляется с тяжёлыми для конструирования объектами и является более читабельным, поскольку явно выражает намерения разработчика.
Хотя иногда тяжело решить, стоит ли использовать опциональный тип, вы точно не должны его использовать для обработки ошибок. Он лучше всего подходит для тех случаев, когда отсутствие значения является нормальным поведением программы.
Простой пример
--------------
Ниже вы можете увидеть простой пример того, что можно сделать с использованием опционального типа:
```
std::optional UI::FindUserNick()
{
if (nick\_available)
return { mStrNickName };
return std::nullopt; // то же самое, как если вернуть просто { };
}
// Использование:
std::optional UserNick = UI->FindUserNick();
if (UserNick)
Show(\*UserNick);
```
В коде выше мы объявили функцию, которая возвращает опциональную строку. Если имя пользователя доступно, она вернёт строку. Если нет, то вернёт `std::nullopt`. Позже мы сможем присвоить это значение опциональному типу и проверить его (у `std::optional` есть оператор приведения к типу `bool`), содержит оно реальное значение или нет. Тип `std::optional` также перегружает `operator*()` для более простого доступа к содержащемуся значению.
В следующих параграфах вы сможете увидеть как создавать `std::optional`, работать с ним, передавать и даже его производительность, которую вам наверняка интересно увидеть.
Серия
-----
Эта статья является частью моей серии про библиотечные утилиты C++17. Вот список других тем, про которые я рассказываю:
* [Рефакторинг с использованием C++17 std::optional](https://habr.com/post/369811/).
* Использование std::optional (**этот пост**).
* Обработка ошибок при использовании std::optional (англ. язык).
* Использование std::variant.
* Использование std::any.
* In place конструкторы для std::optional, std::variant и std::any.
* Использование std::string\_view.
* Утилиты C++17 для поиска и конвертации строк.
* Работа с std::filesystem.
* Что-то ещё? :)
Ресурсы по C++17 STL:
* [Полное руководство по C++17 от Николая Йосуттиса (англ. язык)](https://leanpub.com/cpp17).
* [Основы C++, включая C++17 от Кейт Грегори (англ. язык)](https://pluralsight.pxf.io/c/1192940/424552/7490?u=https%3A%2F%2Fwww.pluralsight.com%2Fcourses%2Fcplusplus-fundamentals-c17).
* [Книга рецептов C++17 STL от Яцека Галовицза (англ. язык)](http://amzn.to/2v6KkmV).
OK, теперь давайте поработаем с `std::optional`.
Создание `std::optional`
------------------------
Есть несколько вариантов создания `std::optional`:
```
// пустой:
std::optional oEmpty;
std::optional oFloat = std::nullopt;
// прямой:
std::optional oInt(10);
std::optional oIntDeduced(10); // deduction guides
// make\_optional
auto oDouble = std::make\_optional(3.0);
auto oComplex = make\_optional>(3.0, 4.0);
// in\_place
std::optional> o7{std::in\_place, 3.0, 4.0};
// вызвать vector с прямой инициализацией {1, 2, 3}
std::optional> oVec(std::in\_place, {1, 2, 3});
// копирование/присваивание:
auto oIntCopy = oInt;
```
Как вы можете видеть в примере выше, вам доступна удивительная гибкость создания объекта. Создание объекта очень простое как для примитивных типов, так и для более сложных.
Создание через `in place` особенно интересно и тег `std::in_place` также поддерживается в других типах, таких как `std::any` и `std::variant`.
Например, вы можете написать:
```
// https://godbolt.org/g/FPBSak
struct Point
{
Point(int a, int b) : x(a), y(b) { }
int x;
int y;
};
std::optional opt{std::in\_place, 0, 1};
// vs
std::optional opt{{0, 1}};
```
Это экономит создание временного объекта `Point`.
Я расскажу про `std::in_place` позже, не переключайте канал и оставайтесь с нами.
Возврат `std::optional` из функции
----------------------------------
Если вы возвращаете опциональное значение из функции, то очень удобно вернуть или `std::nullopt`, или результирующее значение:
```
std::optional TryParse(Input input)
{
if (input.valid())
return input.asString();
return std::nullopt;
}
```
В примере выше вы можете видеть, что я возвращаю `std::string`, полученную из `input.asString()` и оборачиваю её в `std::optional`. Если значение недоступно, то функция просто вернёт `std::nullopt`.
Конечно, вы также можете просто объявить пустой опциональный объект в начале вышей функции и присвоить ему посчитанное значение, если оно корректно. Таким образом, мы можем переписать код выше следующим образом:
```
std::optional TryParse(Input input)
{
std::optional oOut; // empty
if (input.valid())
oOut = input.asString();
return oOut;
}
```
Какая версия лучше, зависит от контекста. Я предпочитаю короткие функции, поэтому мой выбор — версия №1 (с несколькими `return`).
Получение значения
------------------
Возможно, самая важная операция для опционального типа (помимо его создания) — это то, как вы можете получить сохранённое значение.
Для этого есть несколько вариантов:
* Использовать `operator*()` и `operator->()` так же, как в итераторах. Если объект не содержит реального значения, то **поведение не определено**!
* `value()` — возвращает значение или бросает исключение [`std::bad_optional_access`](http://en.cppreference.com/w/cpp/utility/optional/bad_optional_access).
* `value_or(default)` — возвращает значение, если доступно, или же возвращает `default`.
Чтобы проверить, есть ли реальное значение в объекте, вы можете использовать метод `has_value()` или просто проверить объект с помощью `if (optional) {...}`, так как у опционального типа перегружен оператор приведения к `bool`.
Например:
```
// с помощью operator*()
std::optional oint = 10;
std::cout<< "oint " << \*opt1 << '\n';
// с помощью value()
std::optional ostr("hello");
try
{
std::cout << "ostr " << ostr.value() << '\n';
}
catch (const std::bad\_optional\_access& e)
{
std::cout << e.what() << "\n";
}
// с помощью value\_or()
std::optional odouble; // пустой
std::cout<< "odouble " << odouble.value\_or(10.0) << '\n';
```
Таким образом, наиболее удобно, возможно, будет проверить, есть ли реальное значение в опциональном объекте, и затем использовать его:
```
// функция вычисления строки:
std::optional maybe\_create\_hello();
// ...
if (auto ostr = maybe\_create\_hello(); ostr)
std::cout << "ostr " << \*ostr << '\n';
else
std::cout << "ostr is null\n";
```
Возможности `std::optional`
---------------------------
Давайте посмотрим, какие ещё есть возможности у опционального типа:
### Изменение значения
Если у вас уже существует опциональный объект, вы можете легго поменять его значение с помощью методов `emplace`, `reset`, `swap` и `assign`. Если вы присваиваете (или обнуляете) объекту `std::nullopt`, то у реального объекта, который хранится в опциональном, будет вызван деструктор.
Вот небольшой пример:
```
#include
#include
#include
class UserName
{
public:
explicit UserName(const std::string& str) : mName(str)
{
std::cout << "UserName::UserName(\'";
std::cout << mName << "\')\n";
}
~UserName()
{
std::cout << "UserName::~UserName(\'";
std::cout << mName << "\')\n";
}
private:
std::string mName;
};
int main()
{
std::optional oEmpty;
// emplace:
oEmpty.emplace("Steve");
// Вызовется ~Steve и создастся Mark:
oEmpty.emplace("Mark");
// Обнулить объект
oEmpty.reset(); // вызовется ~Mark
// То же самое:
//oEmpty = std::nullopt;
// Присвоить новое значение:
oEmpty.emplace("Fred");
oEmpty = UserName("Joe");
}
```
Этот код доступен здесь: [@Coliru](http://coliru.stacked-crooked.com/a/bea3f18a89cdbc3f).
### Сравнения
`std::optional` позволяет вам сравнивать содержащиеся в нём объекты почти "нормально", но с небольшими исключениями, когда операнды являются `std::nullopt`. См. ниже:
```
#include
#include
int main()
{
std::optional oEmpty;
std::optional oTwo(2);
std::optional oTen(10);
std::cout << std::boolalpha;
std::cout << (oTen > oTwo) << "\n";
std::cout << (oTen < oTwo) << "\n";
std::cout << (oEmpty < oTwo) << "\n";
std::cout << (oEmpty == std::nullopt) << "\n";
std::cout << (oTen == 10) << "\n";
}
```
При выполнении кода выше, будет выведено:
```
true // (oTen > oTwo)
false // (oTen < oTwo)
true // (oEmpty < oTwo)
true // (oEmpty == std::nullopt)
true // (oTen == 10)
```
Этот код доступен здесь: [@Coliru](http://coliru.stacked-crooked.com/a/f77422dc68f3cb09).
Примеры с `std::optional`
-------------------------
Ниже вы найдёте два примера, где `std::optional` подходит идеально.
### Имя пользователя с необязательным никнеймом и возрастом
```
#include
#include
class UserRecord
{
public:
UserRecord (const std::string& name, std::optional nick, std::optional age)
: mName{name}, mNick{nick}, mAge{age}
{
}
friend std::ostream& operator << (std::ostream& stream, const UserRecord& user);
private:
std::string mName;
std::optional mNick;
std::optional mAge;
};
std::ostream& operator << (std::ostream& os, const UserRecord& user)
{
os << user.mName << ' ';
if (user.mNick) {
os << \*user.mNick << ' ';
}
if (user.mAge)
os << "age of " << \*user.mAge;
return os;
}
int main()
{
UserRecord tim { "Tim", "SuperTim", 16 };
UserRecord nano { "Nathan", std::nullopt, std::nullopt };
std::cout << tim << "\n";
std::cout << nano << "\n";
}
```
Этот код доступен здесь: [@Coliru](http://coliru.stacked-crooked.com/a/f02d37fc4319bcd8).
### Парсинг целых чисел из командной строки
```
#include
#include
#include
std::optional ParseInt(char\*arg)
{
try
{
return { std::stoi(std::string(arg)) };
}
catch (...)
{
std::cout << "cannot convert \'" << arg << "\' to int!\n";
}
return { };
}
int main(int argc, char\* argv[])
{
if (argc >= 3)
{
auto oFirst = ParseInt(argv[1]);
auto oSecond = ParseInt(argv[2]);
if (oFirst && oSecond)
{
std::cout << "sum of " << \*oFirst << " and " << \*oSecond;
std::cout << " is " << \*oFirst + \*oSecond << "\n";
}
}
}
```
Этот код доступен здесь: [@Coliru](http://coliru.stacked-crooked.com/a/76118c6062bad7c4).
Код выше использует опциональный тип данных для того, чтобы показать, успешно ли выполнено преобразование. Обратите внимание, что на самом деле мы обернули исключения, которые могут быть выброшены C++, в опциональный тип данных, поэтому мы пропустим все ошибки, связанные с этим. Этот момент достаточно спорный, так как обычно мы должны сообщать пользователю об ошибках.
### Другие примеры
* Представление других необязательных записей для ваших типов. Как в примере с аккаунтом пользователя. Лучше использовать `std::optional`, чем оставлять коментарии вроде: `// если ключ равен 0xDEADBEEF, то он пустой` или что-то в этом роде.
* Возвращаемые значения дял функций поиска (предполагая то, что вас не заботят возникающие при этом ошибки, например: сброс соединения, ошибки БД и т. д.).
Производительность и анализ использования памяти
------------------------------------------------
Когда вы используете `std::optional`, вы платите за это увеличенным использованием памяти. Как минимум, одним дополнительным байтом.
Если подходить абстрактно, то ваша версия STL может реализовывать опциональный тип данных как:
```
template
class optional
{
bool \_initialized;
std::aligned\_storage\_t \_storage;
public:
// Методы
};
```
В кратце, `std::optional` просто оборачивает ваш тип, подготавливает место для него и добавляет один логический параметр. Это означает, что он увеличит размер вашего типа в соответствии с правилами выравнивания.
Есть один коментарий для [этой конструкции](https://www.reddit.com/r/cpp/comments/8hlo01/using_c17_stdoptional/dykvlcg): "Ни одна стандартная библиотека не сможет реализовать `std::optional` так (она должна использовать `union` из-за `constexpr`)". Поэтому код выше просто демонстрирует пример, а не реальную реализацию.
Правила выравнивания важны, как говорит стандарт:
> Шаблонный класс optional [optional.optional]:
>
> Содержащееся значение должно располагаться в регионе памяти, соответственно выровненному для типа `T`.
Например:
```
// sizeof(double) = 8
// sizeof(int) = 4
std::optional od; // sizeof = 16 bytes
std::optional oi; // sizeof = 8 bytes
```
В то время как `bool` обычно занимает один байт, опциональный тип занных вынужден подчиняться правилам выравнивания. Таким образом, размер `std::optional` больше, чем `sizeof(T) + 1`.
Например, если у вас есть такой тип:
```
struct Range
{
std::optional mMin;
std::optional mMax;
};
```
То он займёт больше места, чем если бы вы использовали свой тип вместо `std::optional`:
```
struct Range
{
bool mMinAvailable;
bool mMaxAvailable;
double mMin;
double mMax;
};
```
В первом случае размер структуры равен 32 байтам! Во втором случае всего лишь 24.
[Тестовый пример на Compiler Explorer](https://godbolt.org/g/XUJZKL).
По ссылке великолепное объяснение насчёт производительности и использованию памяти, взятое из документации boost: [вопросы производительности](https://www.boost.org/doc/libs/1_67_0/libs/optional/doc/html/boost_optional/tutorial/performance_considerations.html).
И в статье ["Эффективные опциональные значения"](https://akrzemi1.wordpress.com/2015/07/15/efficient-optional-values/) автор рассуждает, как написать обёртку для опционального типа, которая может быть немного быстрее.
Интересно, есть ли шанс использовать хоть какую-то магию компилятора и повторно использовать некоторое пространство, чтобы поместить этот дополнительный флаг "инициализации объекта” внутри опционального типа. Тогда бы никакого дополнительного пространства не было бы необходимо.
Особенный случай: `std::optional` и `std::optional`
---------------------------------------------------
В то время как вы можете использовать `std::optional` для любого типа, которого захотите, вам надо проявить особое внимание при использовании опционального типа с логическим типом и указателями.
`std::optional ob` — о чём это говорит? С этой конструкцией вы имеете логический тип с тремя состояниями. Поэтому, если он вам и правда нужен, возможно лучше использовать настоящий троичный тип — [~~std::tribool~~ boost::tribool (**правка**: Antervis)](https://www.boost.org/doc/libs/1_67_0/doc/html/tribool.html).
Более того, использование такого типа может сбивать с толку, потому что `ob` преобразуется в `bool` если в нём внутри есть значение и `*ob` возвращает хранимое значение (если оно доступно).
Похожая ситуация может проявиться с указателями:
```
// Не используйте так! Это только пример!
std::optional opi { new int(10) };
if (opi && \*opi)
{
std::cout << \*\*opi << std::endl;
delete \*opi;
}
if (opi)
std::cout << "opi is still not empty!";
```
Указатель на `int` на самом деле является `nullable` типом, поэтому оборачивание в опциональный тип только усложнит его использование.
Итог
----
Фух! Да, это было очень много текста про опциональный тип, но это не всё.
Тем не менее, мы рассмотрели основное использование, создание и оперирование эти удобным типом. Я считаю, что у нас есть много случаев, когда опциональный тип подходит намного лучше, чем использование некоторых предопределённых значений для представления `nullable` типов.
Я бы хотел напомнить следующие вещи про опциональный тип:
* `std::optional` является обёрткой для того, чтобы выразить `nullable` тип.
* `std::optional` не использует динамическое выделение памяти.
* `std::optional` может содержать значение или быть пустым.
+ Используйте `operator*()`, `operator->()`, `value()`, `value_or()` для получения реального значения.
* `std::optional` неявно приводится к `bool`, таким образом вы можете легко проверить, содержится ли в нём какое-либо значение, или нет. | https://habr.com/ru/post/372103/ | null | ru | null |
# Как сделать VPN-туннель для недружественного почтового сервера
В [предыдущей статье](https://habr.com/ru/post/662555), где рассказывалось о признании моего почтового сервера «недружественным», я упоминал о том, что смог обойти введённые ограничения с помощью аренды дополнительного виртуального сервера на территории РФ и проброса до него VPN-туннеля от основного сервера. После публикации статьи мне пришло несколько личных сообщений с просьбой рассказать подробнее о процессе настройки такого туннеля. В этой статье я постараюсь как можно более подробно описать этот процесс.
Введение
--------
В статье предполагается, что на всех серверах установлена ОС Ubuntu 20.04, а в качестве почтового сервера используется Postfix. В целом, описанные здесь методы, скорее всего, будут применимы к любому дистрибутиву Linux, а также и к другим UNIX-подобным ОС (например, FreeBSD), но вам нужно будет сделать поправки в части используемого менеджера пакетов, фаервола и, возможно, настроек сетевой маршрутизации.
Добавлю также, что VPN-туннель между серверами можно использовать не только для почты, но и для проксирования любого другого протокола, где важно знать оригинальный IP-адрес клиента и где невозможно получить его каким-то иным способом, кроме как средствами нижележащего протокола транспортного уровня (TCP или UDP). Например, для HTTP достаточно простого обратного прокси, так как в нём реальный IP можно передавать с помощью заголовков X-Forwarded-For. В случае с SMTP также возможна настройка промежуточного почтового сервера (релея), но по сравнению с поднятием VPN это гораздо более трудоёмкая задача, поэтому рассматривать такой вариант мы здесь не будем.
Сценарий использования
----------------------
Наш сценарий использования можно описать следующим образом. У нас есть основной сервер (назовём его mail.mydomain.com), который принимает и отправляет электронную почту. При этом существует определённый почтовый домен (например, unfriendly.org), MX-сервера которого не принимают входящие соединения от mail.mydomain.com из-за его «недружественности», не позволяя ему слать почту на адреса @unfriendly.org. Приём почты от @unfriendly.org тоже не работает по аналогичным причинам.
Мы арендуем дополнительный сервер-шлюз (назовём его vpn.mail.mydomain.com), который для MX unfriendly.org «недружественным» не является, и хотим установить между нашим шлюзом и основным сервером VPN-туннель, чтобы иметь возможность обмениваться почтой между @unfriendly.org и mail.mydomain.com.
Отдельно отметим, что мы НЕ хотим, чтобы *все* исходящие соединения с mail.mydomain.com шли через VPN — через наш шлюз должны идти соединения только при отправке на @unfriendly.org (и другие проблемные домены, если они есть), а все остальные соединения должны идти напрямую. В итоге должна получиться следующая схема:
(создано на скорую руку в app.diagrams.net)Для поднятия туннеля будем использовать OpenVPN. Я использовал информацию из [вот этого руководства](https://www.digitalocean.com/community/tutorials/how-to-set-up-and-configure-an-openvpn-server-on-ubuntu-20-04) по его настройке в качестве стартовой точки. Сначала нам нужно установить пакет OpenVPN в систему. Рекомендую устанавливать его из [официального репозитория](https://community.openvpn.net/openvpn/wiki/OpenvpnSoftwareRepos#DebianUbuntu:UsingOpenVPNaptrepositories), для этого выполняем следующие команды:
```
# wget -O - https://swupdate.openvpn.net/repos/repo-public.gpg | apt-key add -
# echo "deb http://build.openvpn.net/debian/openvpn/stable focal main" > /etc/apt/sources.list.d/openvpn-aptrepo.list
# apt update && apt install openvpn
```
Далее перемещаемся в папку `/etc/openvpn/server` и генерируем общий ключ для TLS-аутентификации (мы будем использовать его и на сервере, и на клиенте):
```
$ cd /etc/openvpn/server
$ sudo openvpn --genkey secret ta.key
```
Теперь создадим файл конфигурации сервера `server.conf` в той же папке. Ниже привожу содержимое этого файла с дополнительными комментариями:
```
# Понижаем привилегии процесса после запуска
# в целях безопасности (необязательно)
user nobody
group nogroup
# Используем виртуальный драйвер TUN (сетевой уровень)
dev tun
# Здесь я использовал нестандартный порт,
# но можно использовать любой другой.
# По умолчанию используется порт 1194
port 6876
# Рекомендуется использовать протокол UDP.
# Чтобы понять, почему - гуглим "TCP Meltdown"
proto udp
# Сертификаты и приватные ключи.
# Мы создадим их на следующих шагах данного руководства
ca ca.crt
cert vpn.mail.mydomain.com.crt
key vpn.mail.mydomain.com.key
# Настройки шифрования и аутентификации TLS.
# Мы будем использовать эллиптические кривые,
# поэтому алгоритм DHE можно отключить
dh none
tls-crypt ta.key
cipher AES-256-GCM
auth SHA512
# Сетевые настройки
topology subnet
server 172.16.0.0 255.255.255.0
keepalive 10 120
# В этой папке будем хранить настройку
# статического IP-адреса для клиента
client-config-dir /etc/openvpn/server/ccd
# Необходимо при понижении привилегий
persist-key
persist-tun
# Отправляем уведомление клиенту при остановке/перезапуске сервера
explicit-exit-notify 1
# Уровень логирования
verb 3
```
Чтобы установить статический IP-адрес в VPN-сети для нашего почтового сервера, создадим папку `/etc/openvpn/server/ccd` и добавим туда файл `mail.mydomain.com` со следующей строчкой:
```
ifconfig-push 172.16.0.2 255.255.255.0
```
Локальный IP-адрес сервера (vpn.mail.mydomain.com) будет 172.16.0.1, клиента (mail.mydomain.com) — 172.16.0.2.
Дополнительно вы можете жёстко задать параметры шифрования для использования эллиптических кривых, особенно если у вас другая ОС с более старой версией OpenSSL, где могут поддерживаться не все современные наборы шифров. Как это сделать, см. [здесь](https://habr.com/ru/post/663566/comments/#comment_24307766) (спасибо за материал пользователю [@Maxim\_Q](/users/maxim_q)).
#### Настройка фаервола
В Ubuntu 20.04 в качестве фаервола используется `ufw`, который является фронтендом для популярного в Linux `iptables`. Помимо правил, добавляемых с помощью команд, в `ufw` есть конфигурационные файлы, позволяющие прописывать дополнительные правила в формате `iptables`. Откроем файл `/etc/ufw/before.rules` и добавим в начало следующие строчки:
```
*nat
-A PREROUTING -i eth0 -p tcp -m tcp --dport 25 -j DNAT --to-destination 172.16.0.2:25
-A POSTROUTING -s 172.16.0.0/24 -o eth0 -j MASQUERADE
COMMIT
```
Здесь добавляется два правила в таблицу NAT:
1. `-A PREROUTING ...` перенаправляет входящие TCP-соединения на 25-й порт с интерфейса `eth0` на адрес 172.16.0.2 (то есть на наш почтовый сервер mail.mydomain.com).
2. `-A POSTROUTING ...` разрешает исходящие соединения из локальной VPN-сети на интерфейс `eth0` (в интернет) путём настройки SNAT для исходящих пакетов.
**NB:** Проверьте (например, через `ifconfig`), что ваш основной сетевой интерфейс называется именно `eth0`. Если это не так, укажите в правилах корректное название.
Дополнительно нужно включить и разрешить форвардинг IPv4-пакетов. Для этого сначала отредактируем `/etc/sysctl.conf` и раскомментируем в нём строчку `net.ipv4.ip_forward=1`. Затем применим новые настройки с помощью команды:
```
# sysctl -p
```
Теперь в файле `/etc/default/ufw` находим строчку `DEFAULT_FORWARD_POLICY="DROP"` и меняем DROP на ACCEPT. Осталось только включить `ufw` и разрешить через него входящие SMTP- и OpenVPN-соединения. Не забываем также разрешить и SSH-соединения, чтобы не заблокировать себе доступ:
```
# ufw allow ssh
# ufw allow 25/tcp
# ufw allow 6876/udp
# ufw enable
```
**NB:** Не забудьте указать корректный номер порта OpenVPN вместо 6876, если вы используете другой порт (например, стандартый 1194).
Установка и настройка VPN-клиента
---------------------------------
Сначала на машину mail.mydomain.com нужно установить пакет OpenVPN — делаем это таким же способом, как на VPN-сервере. Затем копируем сгенерированный на предыдущем этапе общий ключ `ta.key` с VPN-сервера в папку `/etc/openvpn/client`. Далее создаём конфигурационный файл `/etc/openvpn/client/client.conf`:
```
client
# Понижаем привилегии процесса после запуска
# в целях безопасности (необязательно)
user nobody
group nogroup
# Используем виртуальный драйвер TUN и протокол UDP
dev tun
proto udp
# Настройки подключения к удалённому серверу
remote vpn.mail.mydomain.com 6876
resolv-retry infinite
nobind
# Сертификаты и приватные ключи.
# Мы создадим их на следующих шагах данного руководства
ca ca.crt
cert mail.mydomain.com.crt
key mail.mydomain.com.key
remote-cert-tls server
# Настройки шифрования и аутентификации TLS
tls-crypt ta.key
cipher AES-256-GCM
auth SHA512
auth-nocache
# Скрипт для настройки маршрутизации после поднятия туннеля.
# Мы создадим его на предпоследнем этапе данного руководства
script-security 2
up openvpn_routes.sh
# Необходимо при понижении привилегий
persist-key
persist-tun
# Уровень логирования
verb 3
```
**Замечание**
Если вы понижаете привилегии процесса OpenVPN, то при остановке клиента или сервера через `systemctl` или при перезагрузке системы будете наблюдать в логе сообщения вида:
```
MMM dd HH:mm:ss mail.mydomain.com openvpn[123456]: RTNETLINK answers: Operation not permitted
MMM dd HH:mm:ss mail.mydomain.com openvpn[123456]: Linux ip addr del failed: external program exited with error status: 2
```
Объясню, в чём дело: OpenVPN хочет удалить маршрут к VPN-подсети из системы, но не может этого сделать из-за пониженных привилегий (с добавлением маршрута проблем нет, так как привилегии понижаются не сразу, а после завершения начальной настройки). Но это не является чем-то критичным, так как маршрут всё равно пропадает автоматически после удаления туннельного сетевого интерфейса, что как раз и происходит при остановке OpenVPN.
Если вы всё же хотите избавиться от этих сообщений, можно попробовать сделать это, например, [вот так](https://openvpn.net/community-resources/hardening-openvpn-security/#unprivileged-mode-linux-only). Я этот метод не пробовал, поэтому не могу сказать, будут ли здесь какие-то ещё проблемы, но лично мне этот вариант кажется не очень безопасным, так как он, по сути, сводится к разрешению выполнения команды `ip` для непривилегированных пользователей.
Выпуск сертификатов для аутентификации
--------------------------------------
Альтернативный вариантЕсли вам лень возиться с настройкой собственного центра сертификации, можно попробовать использовать другой способ аутентификации — статический ключ. [Вот здесь](https://openvpn.net/community-resources/static-key-mini-howto/) описывается, как это сделать. Вам нужно будет подправить конфигурацию и удалить все упоминания о сертификатах, а также убрать`client-config-dir` и прописать настройки IP-адресов вручную на стороне клиента и сервера. Убедитесь, что сервер запускается, путём выполнения команды:
```
# systemctl start openvpn-server@server
```
Если что-то пошло не так, проверьте лог:
```
# journalctl -u openvpn-server@server -e
```
Также стоит добавить сервер в автозагрузку с помощью следующей команды:
```
# systemctl enable openvpn-server@server
```
Если всё в порядке, то переходите к следующему разделу данного руководства «Настройка маршрутизации».
OpenVPN по умолчанию использует сертификатную аутентификацию. Это значит, что при подключении клиент и сервер должны обменяться [X.509](https://ru.wikipedia.org/wiki/X.509)-сертификатами, подписанными доверенным удостоверяющим центром (УЦ). Такой центр мы создадим самостоятельно и сначала выпустим корневой сертификат, который установим и на сервер, и на клиент, а затем создадим и подпишем для них пользовательские сертификаты.
Почему мы не можем использовать для выпуска сертификата, например, сервис Let's Encrypt? Всё просто: если наш VPN-сервер будет доверять УЦ Let's Encrypt, то без дополнительных настроек кто угодно сможет запросить у них сертификат и использовать его для подключения к нашему VPN, чего мы, конечно же, не хотим. Поэтому мы развернём свой собственный центр сертификации, работу которого мы можем контролировать. В этом нам поможет пакет EasyRSA, представляющий собой обёртку над популярной утилитой OpenSSL.
Отметим также, что УЦ на базе EasyRSA необязательно устанавливать именно на VPN-сервер, более того, такой вариант менее безопасен, так как на сервере будет храниться приватный ключ вашего центра сертификации, которым можно подписывать пользовательские сертификаты и таким образом управлять доступом к вашему VPN-серверу. Оптимальный вариант — установить УЦ на ваш домашний компьютер, ноут и т.д. (если вы параноик, можете вообще отключить его от сети и передавать все данные на флешках).
Пакет EasyRSA используется не только для создания центра сертификации, но и для генерации приватных ключей и запросов на выпуск сертификатов. Работает это так:
1. На сервере vpn.mail.mydomain.com генерируем пару «приватный ключ» — «запрос на сертификат».
2. Отправляем файл запроса в УЦ.
3. УЦ создаёт и подписывает сертификат и отправляет его обратно на сервер.
4. Аналогичные операции проводим на машине mail.mydomain.com.
Обратите внимание, что ни один приватный ключ (в том числе ключ самого УЦ) не покидает машины, на которой он генерируется. Это одно из важных преимуществ использования [криптосистемы с открытым ключом](https://ru.wikipedia.org/wiki/%D0%9A%D1%80%D0%B8%D0%BF%D1%82%D0%BE%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D1%81_%D0%BE%D1%82%D0%BA%D1%80%D1%8B%D1%82%D1%8B%D0%BC_%D0%BA%D0%BB%D1%8E%D1%87%D0%BE%D0%BC).
#### Установка центра сертификации
Как уже говорил ранее, этот шаг желательно выполнять на отдельной машине. Для упрощения будем полагать, что на ней также стоит Ubuntu 20.04.
Сначала установим пакет easy-rsa:
```
# apt update && apt install easy-rsa
```
Теперь создадим в домашнем каталоге папку `easyrsa`, в которой будем хранить настройки, сертификат и приватный ключ нашего УЦ:
```
$ cd ~
$ mkdir easyrsa
$ chmod 700 easyrsa
```
Добавим во вновь созданную папку символьные ссылки на исполняемые и конфигурационные файлы EasyRSA, чтобы не обновлять их каждый раз вручную при обновлении пакета:
```
$ ln -s /usr/share/easy-rsa/* ~/easyrsa/
```
Начиная с версии 2.4, в OpenVPN возможно использование криптографии на эллиптических кривых, которая является более надёжной по сравнению с традиционным RSA. Чтобы использовать эллиптические кривые (в данном случае предлагается кривая [secp521r1](https://neuromancer.sk/std/secg/secp521r1)), создадим файл `~/easyrsa/vars` со следующим содержимым:
```
set_var EASYRSA_ALGO "ec"
set_var EASYRSA_CURVE "secp521r1"
set_var EASYRSA_DIGEST "sha512"
```
Далее выполняем команды:
```
$ cd ~/easyrsa
$ ./easyrsa init-pki
```
На момент написания данного текста в версии OpenSSL в Ubuntu 20.04 есть небольшой баг, из-за которого при генерации ключей может появляться сообщение вида `random number generator:RAND_load_file:Cannot open file` ([источник](https://github.com/OpenVPN/easy-rsa/issues/261#issuecomment-685929163)). Оно не свидетельствует о критической ошибке, но от него можно избавиться, создав указанный файл вручную:
```
$ dd if=/dev/urandom of=pki/.rnd bs=256 count=1
```
Осталось инициализировать сам УЦ:
```
$ ./easyrsa build-ca
```
В ходе создания УЦ вас попросят ввести парольную фразу — рекомендуется сделать её достаточно сложной, чтобы её нельзя было подобрать. Также нужно будет задать имя (Common Name) для вашего УЦ — можно использовать в качестве него, например, имя хоста вашей машины. Если вы пропустите этот шаг, по умолчанию будет использоваться имя «Easy-RSA CA», не являющееся особо примечательным, поэтому рекомендую вместо него задать своё имя — тогда при проверке выпущенных сертификатов будет сразу понятно, что они подписаны именно вашим УЦ.
#### Выпуск сертификата для VPN-сервера
Теперь займёмся выпуском сертификата для OpenVPN-сервера на машине vpn.mail.mydomain.com. Для этого на неё сначала необходимо установить пакет EasyRSA и выполнить все команды до `init-pki` включительно (см. выше). Далее нам необходимо сгенерировать приватный ключ и запрос на сертификат, который мы отправим в наш УЦ:
```
$ ./easyrsa gen-req vpn.mail.mydomain.com nopass
```
Обратите внимание на параметр `nopass` — если его не указать, то EasyRSA попросит вас задать парольную фразу для генерируемого ключа, и VPN-сервер каждый раз при запуске будет её запрашивать (по очевидным причинам нам такой вариант не подходит). Также в ходе выполнения команды `gen-req` у вас снова запросят имя (Common Name), на этот раз для будущего сертификата — тут можно просто нажать Enter, чтобы использовать имя, которое вы указали в параметрах команды. В итоге у вас должны сгенерироваться два файла:
`~/easyrsa/pki/private/vpn.mail.mydomain.com.key` — это приватный ключ. Его необходимо переместить в папку `/etc/openvpn/server`, предварительно сменив владельца на `root`:
```
$ cd ~/easyrsa/pki/private/
$ sudo -s
# chown root:root vpn.mail.mydomain.com.key
# mv vpn.mail.mydomain.com.key /etc/openvpn/server/
```
`~/easyrsa/pki/reqs/vpn.mail.mydomain.com.req` — это запрос на создание сертификата. Этот файл необходимо переместить на машину УЦ в любую папку (например, `/tmp`), затем на ней же выполнить команды:
```
$ cd ~/easyrsa
$ ./easyrsa import-req /tmp/vpn.mail.mydomain.com.req vpn.mail.mydomain.com
$ ./easyrsa sign-req server vpn.mail.mydomain.com
```
Убеждаемся, что Common Name в запросе на сертификат совпадает с именем хоста соответствующей машины (в данном случае vpn.mydomain.com) и, если всё верно, вводим «yes», после этого вас ещё попросят ввести парольную фразу, которую вы придумали ранее при создании УЦ. Сертификат будет сгенерирован по следующему пути: `~/easyrsa/pki/issued/vpn.mail.mydomain.com.crt`. Берём его вместе с корневым сертификатом УЦ, который находится в `~/easyrsa/pki/ca.crt`, и копируем на VPN-сервер в папку `/etc/openvpn/server`. Не забываем про настройки владельца и права доступа для этих файлов (`chown root:root` и `chmod 600` соответственно).
На данном этапе настройка VPN-сервера завершена. Чтобы запустить сервер, выполняем на нём команду:
```
# systemctl start openvpn-server@server
```
Чтобы добавить сервер в автозагрузку, выполняем:
```
# systemctl enable openvpn-server@server
```
Если при запуске возникла ошибка, посмотреть лог можно с помощью следующей команды:
```
# journalctl -u openvpn-server@server -e
```
Наиболее частые ошибки возникают из-за проблем с конфигурацией (опечатки, пропуски) или отсутствия необходимых файлов (сертификат, приватный ключ и т.д.). Также, если вы неправильно настроили права доступа к файлам сертификатов и ключей, в логе появится предупреждение об этом.
**Выпуск сертификата для VPN-клиента**
Как и на VPN-сервере, на машине mail.mydomain.com тоже нужно установить пакет EasyRSA и выполнить `init-pki`. После этого создаём приватный ключ и запрос на сертификат:
```
$ ./easyrsa gen-req mail.mydomain.com nopass
```
Перемещаем сгенерированный приватный ключ из `~/easyrsa/pki/private/mail.mydomain.com.key` в папку `/etc/openvpn/client`, не забывая про смену владельца:
```
$ cd ~/easyrsa/pki/private/
$ sudo -s
# chown root:root mail.mydomain.com.key
# mv mail.mydomain.com.key /etc/openvpn/client/
```
Затем отправляем файл запроса `~/easyrsa/pki/reqs/mail.mydomain.com.req` на машину УЦ (например, в `/tmp`), импортируем, выпускаем сертификат:
```
$ cd ~/easyrsa
$ ./easyrsa import-req /tmp/mail.mydomain.com.req mail.mydomain.com
$ ./easyrsa sign-req client mail.mydomain.com
```
Ещё раз вводим «yes» (предварительно убедившись, что Common Name совпадает с mail.mydomain.com) и парольную фразу. Как и в предыдущий раз, сертификат создаётся по пути: `~/easyrsa/pki/issued/mail.mydomain.com.crt`. Копируем его и корневой сертификат из `~/easyrsa/pki/ca.crt` на машину mail.mydomain.com в папку `/etc/openvpn/client`, в очередной раз не забывая про настройку прав доступа.
На этом, казалось бы, всё, и VPN-клиент готов к работе, но остаётся ещё один момент — маршрутизация. Не забыли про строчку `up openvpn_routes.sh` в конфигурации клиента? Сейчас мы с этим разберёмся.
Настройка маршрутизации на VPN-клиенте
--------------------------------------
Напомню, что наш сценарий заключается в том, что направлять через VPN мы хотим не весь интернет-трафик, а только определённые соединения. Здесь есть небольшая проблема, так как обычно для всех исходящих интернет-соединений используется шлюз по умолчанию, ассоциированный с основным сетевым интерфейсом (например, `eth0`). Напомню, что на VPN-сервере мы специально не включали SNAT для входящих IP-пакетов, так как при подключении к почтовому серверу нам важно видеть реальный IP-адрес удалённой стороны вместо локального адреса VPN-сервера (172.16.0.1). Если ничего не настраивать, то при входящем соединении через VPN ответ этому IP-адресу, согласно правилам маршрутизации, почтовый сервер отправит через основной сетевой интерфейс. Очевидно, что ни к чему хорошему это привести не может.
Решением данной проблемы является создание альтернативной таблицы маршрутизации и задание правил для её использования. Источником для написания данного раздела послужила [эта статья](https://kindlund.wordpress.com/2007/11/19/configuring-multiple-default-routes-in-linux/).
Сначала нам нужно указать системе, что мы создаём новую таблицу маршрутизации. В данном руководстве она будет называться `openvpn`. Создадим файл `/etc/iproute2/rt_tables.d/openvpn.conf` с единственной строчкой:
```
1 openvpn
```
Теперь создаём shell-скрипт `/etc/openvpn/client/openvpn_routes.sh` со следующим содержимым:
```
#!/bin/bash
ip route add default via 172.16.0.1 dev $dev table openvpn
ip rule add from 172.16.0.2 table openvpn
ip rule add to 172.16.0.2 table openvpn
```
Не забываем сделать его исполняемым:
```
# chmod +x /etc/openvpn/client/openvpn_routes.sh
```
Согласно настройкам клиента, этот скрипт будет выполняться каждый раз после поднятия туннельного сетевого интерфейса. Давайте разберёмся, что здесь происходит:
1. Команда `ip route add default ...` добавляет маршрут со шлюзом по умолчанию 172.16.0.1 (локальный IP нашего VPN-сервера) через интерфейс `$dev` в таблицу маршрутизации `openvpn`. Значение параметра `$dev` устанавливается самим клиентом OpenVPN перед запуском скрипта и содержит название туннельного интерфейса для VPN-соединения (обычно это `tun0`).
2. Команда `ip rule add from ...` добавляет правило маршрутизации, предписывающее использовать таблицу `openvpn` для всех исходящих соединений с IP-адреса 172.16.0.2 (это локальный IP нашего VPN-клиента).
3. Команда `ip rule add to ...` добавляет аналогичное правило маршрутизации, но оно относится уже к входящим соединениям.
Таким образом, после выполнения данного скрипта все соединения, где одной из конечных точек является локальный IP-адрес машины mail.mydomain.com в VPN-туннеле (т.е. 172.16.0.2), будут маршрутизироваться через этот туннель. Чтобы проверить это, сначала поднимаем клиент:
```
# systemctl start openvpn-client@client
```
Рекомендую также добавить его в автозапуск:
```
# systemctl enable openvpn-client@client
```
Если клиент стартовал без ошибок, для начала рекомендую попинговать 172.16.0.1, чтобы убедиться, что соединение с сервером действительно есть. Теперь попробуем соединиться через VPN с сервисом [telnetmyip.com](http://telnetmyip.com/), чтобы убедиться, что маршрутизация работает корректно. С помощью `telnet` это можно сделать так:
```
$ telnet -b 172.16.0.2 telnetmyip.com
```
У меня этот сервис почему-то ничего не выводит, а просто закрывает соединение (возможно, из-за той же пресловутой «недружественности»). В этом случае можно попробовать ещё через `curl`:
```
$ curl --interface 172.16.0.2 telnetmyip.com
```
Вы получите ответ вида:
```
{
"comment": "## Your IP Address is WW.XX.YY.ZZ (<номер_порта>) ##",
"family": "ipv4",
"ip": "WW.XX.YY.ZZ",
...
}
```
Если WW.XX.YY.ZZ совпадает с внешним IP-адресом машины vpn.mail.mydomain.com, то поздравляю — всё настроено корректно! Замечу, что в случае некорректной настройки вам, скорее всего, вообще не удастся установить соединение.
Входящие соединения можно проверить, подключившись с помощью `telnet` к vpn.mail.mydomain.com на порт 25 с любой сторонней машины (например, с домашней — если, конечно, ваш интернет-провайдер не блокирует 25-й порт на выход). При этом в логах почтового сервера должен появиться ваш реальный внешний IP-адрес, а не локальный адрес VPN-сервера 172.16.0.1.
Настройка Postfix
-----------------
#### Приём почты
Чтобы принимать в Postfix входящие соединения через VPN-туннель, вам не нужно менять никаких настроек — достаточно лишь добавить в DNS вторую MX-запись для вашего почтового домена, указав в ней имя хоста vpn.mail.mydomain.com. Рекомендуется поставить ей низкий приоритет (например, если для основной записи у вас приоритет 10, ставьте 100), чтобы соединения через VPN-шлюз шли только тогда, когда доступ к основному серверу заблокирован с удалённой стороны.
Единственное, что здесь стоит отметить — при соединении с vpn.mail.mydomain.com ваш сервер будет представляться как mail.mydomain.com. Это не должно повлиять на доставку почты, но если вы хотите сделать всё «по феншую», то нужно будет немного пошаманить с конфигурацией. Здесь есть два варианта, которые сводятся к тому, чтобы в `/etc/postfix/master.cf` создать дополнительный SMTP-сервер, который будет принимать соединения через VPN, и прописать ему нужное значение `myhostname`.
Первый вариант: привязать второй SMTP-сервер к IP-адресу в локальной VPN-сети, вот так это будет выглядеть в `master.cf`:
```
172.16.0.2:smtp inet n - y - - smtpd
-o syslog_service_name=postfix/vpn
-o myhostname=vpn.mail.mydomain.com
```
Проблема здесь в том, что если VPN-туннель не поднят, при запуске Postfix выдаст фатальную ошибку: «fatal: bind 172.16.0.2 port 25: Cannot assign requested address». Поэтому я считаю такой способ не очень надёжным (например, если OpenVPN почему-то откажется запускаться, то Postfix тоже не сможет стартовать). Но можно поступить чуть хитрее, а именно — создать сервер, привязанный к другому порту. В примере ниже используется порт 4925 вместо стандартного 25:
```
4925 inet n - y - - smtpd
-o syslog_service_name=postfix/vpn
-o myhostname=vpn.mail.mydomain.com
```
Чтобы это заработало, на VPN-сервере нужно отредактировать файл `/etc/ufw/before.rules`: в правиле `-A PREROUTING ...`, которое мы создавали при настройке сервера, нужно поменять в конце порт 25 на 4925. Затем выполнить команду:
```
# service ufw restart
```
**NB:** Если после этого вы видите, что на стороне Postfix подключение идёт всё ещё на 25-й порт — попробуйте перезагрузить VPN-сервер.
Теперь при подключении к vpn.mail.mydomain.com сервер представится вам именно этим именем. Обратите внимание, что мы также указали для нового сервера `syslog_service_name=postfix/vpn`, чтобы в логе было видно, как маршрутизируется соединение:
```
MMM dd HH:mm:ss mail.mydomain.com postfix/vpn/smtpd[12345]: connect from unknown[WW.XX.YY.ZZ]
```
Если вы используете postscreen и хотите отвечать корректным именем при подключении через VPN, то помимо второго SMTP-сервера нужен будет второй postscreen с соответствующими настройками. Выглядеть это будет так:
```
4925 inet n - y - 1 postscreen
-o syslog_service_name=postfix/vpn
-o myhostname=vpn.mail.mydomain.com
-o smtpd_service_name=vpn-smtpd
-o postscreen_cache_cleanup_interval=0
vpn-smtpd pass - - y - - smtpd
-o syslog_service_name=postfix/vpn
-o myhostname=vpn.mail.mydomain.com
```
Дополнительно вам нужно будет настроить postscreen так, чтобы он обращался к файлу кэша через `proxymap`, иначе получите фатальную ошибку из-за невозможности эксклюзивной блокировки этого файла. Добавляем в `/etc/postfix/main.cf`:
```
postscreen_cache_map = proxy:btree:/var/lib/postfix/postscreen_cache
```
и дело в шляпе.
#### Отправка почты
Для отправки почты через VPN-сервер в первую очередь, конечно, нужно убедиться, что разрешены исходящие соединения по 25-му порту и что у сервера всё в порядке с PTR, SPF и спам-листами. Если с этим проблем нет, то можно приступить к настройке.
Сначала создадим в `/etc/postfix/master.cf` отдельный SMTP-клиент и укажем ему значение `smtp_bind_address`, соответствующее локальному IP-адресу нашего почтовика в VPN-сети — в нашем случае это 172.16.0.2. По умолчанию, если Postfix не может выполнить биндинг на `smtp_bind_address`, он логирует предупреждение и повторяет попытку отправки уже с основного адреса. Postfix 3.7 содержит полезную настройку `smtp_bind_address_enforce`, которую мы можем включить для предотвращения подобного поведения: в этом случае, если VPN-туннель временно не работает, письмо просто вернётся в очередь для повторной отправки.
```
vpn-smtp unix - - y - - smtp
-o syslog_service_name=postfix/vpn
-o myhostname=vpn.mail.mydomain.com
-o smtp_bind_address=172.16.0.2
# для Postfix 3.7 и выше
-o smtp_bind_address_enforce=yes
```
Теперь настроим выборочную отправку писем на определённые домены через VPN. В нашем примере мы хотим отправлять через VPN письма на @unfriendly.org. Создаём файл `/etc/postfix/vpn_transport` со следующей строчкой:
```
unfriendly.org vpn-smtp
```
и добавляем в `/etc/postfix/main.cf`:
```
transport_maps = hash:/etc/postfix/vpn_transport
```
Далее выполняем команды:
```
# postmap /etc/postfix/vpn_transport
# systemctl reload postfix
```
и пробуем отправить письмо на любой адрес в домене unfriendly.org, затем убеждаемся, что при отправке этого письма вы видите в логе не `postfix/smtp`, а `postfix/vpn/smtp`. Аналогичным образом можно добавлять в `/etc/postfix/vpn_transport` другие почтовые домены, не забываем только каждый раз делать `postmap` и `reload`. Конечно, необязательно использовать именно формат `hash` для хранения транспортной таблицы — вы можете хранить эти данные в любом другом удобном вам формате (при условии, что он [поддерживается в Postfix](https://www.postfix.org/DATABASE_README.html#types)), в том числе в каком-нибудь MySQL/MariaDB.
Заключение
----------
В данной статье мы рассмотрели простой способ создания альтернативного канала связи между почтовым сервером и внешним миром, который можно использовать, если по каким-то причинам (например, из-за «недружественности») связь с определёнными MX-хостами через основной канал не работает. Можно отметить следующие достоинства данного способа:
* Простота настройки, особенно по сравнению с поднятием полноценного резервного почтового сервера (backup MX);
* Возможность горизонтального масштабирования: при необходимости можно арендовать ещё один сервер и быстро поднять ещё один резервный канал — вследствие простоты настройки на это уйдёт совсем немного времени;
* Никакие данные не хранятся на VPN-сервере, что особенно важно, если он расположен в РФ;
* Для VPN-сервера можно выбирать самую дешёвую конфигурацию, так как OpenVPN не затрачивает большого количества ресурсов системы, если речь идёт об одном клиенте с небольшими объёмами трафика (что как раз применимо к нашему случаю).
Недостатком данного решения является привязка VPN-шлюза к конкретному почтовому серверу. Если ваша почтовая инфраструктура содержит несколько серверов, развёртывание туннеля может быть затруднено.
Ещё одной потенциальной проблемой, хоть и не связанной непосредственно с VPN, является ручная настройка списка «недружественных» почтовых доменов — при большом количестве пользователей на почтовом сервере это может быть просто неудобно. В теории можно попробовать автоматизировать этот процесс, написав свой собственный сервис, который будет пытаться устанавливать соединение с MX-серверами получателя с разных сетевых интерфейсов и, в зависимости от результатов, выбирать для передачи письма прямой SMTP-транспорт или VPN — но эта тема уже выходит за рамки данной статьи. | https://habr.com/ru/post/663566/ | null | ru | null |
# Строим Data Vault на данных TPC-H – Greenplum + dbtVault
Привет! На связи Артемий – энтузиаст в сфере Data Warehousing, Analytics, DataOps.
Уже продолжительное время я занимаюсь моделированием DWH с использованием dbt, и сегодня пришло время познакомить вас с package для построения Data Vault – **dbtVault**.
В публикации:
* Готовим датасет TPC-H
* Поднимаем кластер Greenplum в Яндекс.Облаке
* Погружаемся в кодогенерацию и макросы dbtVault
* Cимулируем инкрементальное наполнение Data Vault
Кодогенерация для Data Vault
----------------------------
Подход к построению Хранилища Данных на основе методолгии Data Vault или гибридных, схожих с ней, обретает новый виток популярности и интереса в последнее время. Это неудивительно – несмотря на сложность и обилие объектов в БД, преимущества и гибкость однозначно перевешивают в долгосрочной перспективе:
* Единая логическая модель данных – мыслим бизнес-сущностями, а не системами-источниками
* Возможность быстрого, параллельного и инкрементального наполнения Хранилища
* Гибкость расширения модели и схемы данных – новые сущности и атрибуты
* Хэш-сумма для генерации суррогатных ключей и отслеживания изменений атрибутов
Простая схема Data VaultИ любой, кто когда-либо изучал Data Vault согласится, что обойтись без инструментов кодогенерации будет весьма затруднительно. Инструменты этого класса призваны решить ряд задач:
* Генерация кода по шаблонам для десятков и сотен объектов
* Управление метаданными
* Построение графа зависимостей (DAG)
* Документация проекта
Одним из таких инструментов является проект [dbtVault](https://dbtvault.readthedocs.io/en/latest/), который представляет из себя модуль для [dbt](https://habr.com/ru/company/wheely/blog/549614/).
Готовим исходные данные – TPC-H
-------------------------------
Мы будем работать со знаменитым датасетом для сравнения производительности баз данных (benchmarking) [TPC-H](http://www.tpc.org/tpch/). Это синтетические данные, описывающие предметную область оптовых поставок-продаж. К тому же, при генерации можно указать *scale factor* и получить данные в кратном объеме (х10, х100, х1000).
Для тех, кому не терпится приступить к моделированию, я заботливо сгенерировал исходные файлы общим объемом 10Гб и разместил в Yandex Object Storage:
```
mkdir tpch && cd tpch
# option 1 – curl
curl -O "https://storage.yandexcloud.net/otus-dwh/tpch-dbgen/{customer,lineitem,nation,orders,part,partsupp,region,supplier}.csv"
# option 2 – aws s3
aws configure # enter your Key ID / Secret Key
aws --endpoint-url=https://storage.yandexcloud.net s3 ls s3://otus-dwh/tpch-dbgen/ # list files
aws --endpoint-url=https://storage.yandexcloud.net s3 sync s3://otus-dwh/tpch-dbgen/ . # sync files
```
В github gist есть инструкция по генерации файлов самостоятельно: [Generate data with DBGen](https://gist.github.com/kzzzr/4ab36bec6897e48e44e792dc2e706de9#2a-generate-data-with-dbgen)
Готовим кластер Greenplum в Яндекс.Облаке
-----------------------------------------
В целях демонстрации я предлагаю использовать кластер Greenplum в Яндекс.Облаке. Следующей конфигурации будет достаточно для работы с нашим датасетом:
Альтернативно – можно пробовать использовать любую другую СУБД семейства PostgreSQL: Redshift, Vertica, Greenplum. Еще более альтернативно – с минимальными адаптациями код может быть исполнен почти в любой СУБД на ваш выбор. Об этом чуть ниже.
### Наполним Greenplum данными
Сначала создадим определения для таблиц:
DDL scripts to create table
```
CREATE TABLE customer
(C_CUSTKEY INT,
C_NAME VARCHAR(25),
C_ADDRESS VARCHAR(40),
C_NATIONKEY INTEGER,
C_PHONE CHAR(15),
C_ACCTBAL DECIMAL(15,2),
C_MKTSEGMENT CHAR(10),
C_COMMENT VARCHAR(117))
WITH (appendonly=true, orientation=column)
DISTRIBUTED BY (C_CUSTKEY);
CREATE TABLE lineitem
(L_ORDERKEY BIGINT,
L_PARTKEY INT,
L_SUPPKEY INT,
L_LINENUMBER INTEGER,
L_QUANTITY DECIMAL(15,2),
L_EXTENDEDPRICE DECIMAL(15,2),
L_DISCOUNT DECIMAL(15,2),
L_TAX DECIMAL(15,2),
L_RETURNFLAG CHAR(1),
L_LINESTATUS CHAR(1),
L_SHIPDATE DATE,
L_COMMITDATE DATE,
L_RECEIPTDATE DATE,
L_SHIPINSTRUCT CHAR(25),
L_SHIPMODE CHAR(10),
L_COMMENT VARCHAR(44))
WITH (appendonly=true, orientation=column, compresstype=ZSTD)
DISTRIBUTED BY (L_ORDERKEY,L_LINENUMBER)
PARTITION BY RANGE (L_SHIPDATE)
(start('1992-01-01') INCLUSIVE end ('1998-12-31') INCLUSIVE every (30),
default partition others);
CREATE TABLE nation
(N_NATIONKEY INTEGER,
N_NAME CHAR(25),
N_REGIONKEY INTEGER,
N_COMMENT VARCHAR(152))
WITH (appendonly=true, orientation=column)
DISTRIBUTED BY (N_NATIONKEY);
CREATE TABLE orders
(O_ORDERKEY BIGINT,
O_CUSTKEY INT,
O_ORDERSTATUS CHAR(1),
O_TOTALPRICE DECIMAL(15,2),
O_ORDERDATE DATE,
O_ORDERPRIORITY CHAR(15),
O_CLERK CHAR(15),
O_SHIPPRIORITY INTEGER,
O_COMMENT VARCHAR(79))
WITH (appendonly=true, orientation=column, compresstype=ZSTD)
DISTRIBUTED BY (O_ORDERKEY)
PARTITION BY RANGE (O_ORDERDATE)
(start('1992-01-01') INCLUSIVE end ('1998-12-31') INCLUSIVE every (30),
default partition others);
CREATE TABLE part
(P_PARTKEY INT,
P_NAME VARCHAR(55),
P_MFGR CHAR(25),
P_BRAND CHAR(10),
P_TYPE VARCHAR(25),
P_SIZE INTEGER,
P_CONTAINER CHAR(10),
P_RETAILPRICE DECIMAL(15,2),
P_COMMENT VARCHAR(23))
WITH (appendonly=true, orientation=column)
DISTRIBUTED BY (P_PARTKEY);
CREATE TABLE partsupp
(PS_PARTKEY INT,
PS_SUPPKEY INT,
PS_AVAILQTY INTEGER,
PS_SUPPLYCOST DECIMAL(15,2),
PS_COMMENT VARCHAR(199))
WITH (appendonly=true, orientation=column)
DISTRIBUTED BY (PS_PARTKEY,PS_SUPPKEY);
CREATE TABLE region
(R_REGIONKEY INTEGER,
R_NAME CHAR(25),
R_COMMENT VARCHAR(152))
WITH (appendonly=true, orientation=column)
DISTRIBUTED BY (R_REGIONKEY);
CREATE TABLE supplier
(S_SUPPKEY INT,
S_NAME CHAR(25),
S_ADDRESS VARCHAR(40),
S_NATIONKEY INTEGER,
S_PHONE CHAR(15),
S_ACCTBAL DECIMAL(15,2),
S_COMMENT VARCHAR(101))
WITH (appendonly=true, orientation=column)
DISTRIBUTED BY (S_SUPPKEY);
```
Затем наполним таблицы данными. На машине с установленной CLI-утилитой *psql* загрузим csv-файлы в базу:
```
export GREENPLUM_URI="postgres://greenplum:@:5432/postgres"
psql $GREENPLUM\_URI
\copy customer from '/home/dbgen/tpch-dbgen/data/customer.csv' WITH (FORMAT csv, DELIMITER '|');
\copy lineitem from '/home/dbgen/tpch-dbgen/data/lineitem.csv' WITH (FORMAT csv, DELIMITER '|');
\copy nation from '/home/dbgen/tpch-dbgen/data/nation.csv' WITH (FORMAT csv, DELIMITER '|');
\copy orders from '/home/dbgen/tpch-dbgen/data/orders.csv' WITH (FORMAT csv, DELIMITER '|');
\copy part from '/home/dbgen/tpch-dbgen/data/part.csv' WITH (FORMAT csv, DELIMITER '|');
\copy partsupp from '/home/dbgen/tpch-dbgen/data/partsupp.csv' WITH (FORMAT csv, DELIMITER '|');
\copy region from '/home/dbgen/tpch-dbgen/data/region.csv' WITH (FORMAT csv, DELIMITER '|');
\copy supplier from '/home/dbgen/tpch-dbgen/data/supplier.csv' WITH (FORMAT csv, DELIMITER '|');
```
Ура! Теперь мы готовы к наполнению Data Vault.
Инициируем проект dbt
----------------------
**1. Склонируйте себе репо с проектом dbt** [**dbtvault\_greenplum\_demo**](https://github.com/kzzzr/dbtvault_greenplum_demo)
```
git clone https://github.com/kzzzr/dbtvault_greenplum_demo.git
```
**2. Настройте подключение к СУБД Greenplum**
dbt будет искать файл с описанием подключения (хост/порт/логин/пасс) в директории `~/.dbt/profiles.yml`. Подробнее можно почитать в документации dbt – [Configure your profile](https://docs.getdbt.com/dbt-cli/configure-your-profile). По понятным причинам файл не версионируется в репозитории.
Пример содержимого файла `profiles.yml`:
```
config:
send_anonymous_usage_stats: False
use_colors: True
partial_parse: True
dbtvault_greenplum_demo:
outputs:
dev:
type: postgres
threads: 2
host: {yc-greenplum-host}
port: 5432
user: greenplum
pass: {yc-greenplum-pass}
dbname: postgres
schema: public
target: dev
```
**3. Установите dbt версии 0.19.0**
Проект был подготовлен и протестирован именно на этой версии. dbt – это не что иное как python-приложение. Есть множество [вариантов установки dbt](https://docs.getdbt.com/dbt-cli/installation). Но самый простой вариант – использовать готовый Pipfile в репозитории:
```
pipenv install
pipenv shell
```
Проверьте корректность установки и подключение к СУБД:
```
dbt --version
dbt debug
```
**4. Импортируем модуль dbtVault**
Здесь начинается особая магия. Для кодогенерации Data Vault нам понадобится зависимость (модуль или package) [dbtVault](https://dbtvault.readthedocs.io/en/latest/). Оригинальная версия модуля предназначена для работы только с СУБД Snowflake. Но после ряда нехитрых манипуляций модуль готов к работе с Greenplum (PostgreSQL): [**47e0261**](https://github.com/kzzzr/dbtvault/commit/47e0261cea67c3284ea409c86dacdc31b1175a39).
Устанавливаемые модули объявляются в файле `packages.yml` проекта:
```
packages:
# - package: Datavault-UK/dbtvault
# version: 0.7.3
- git: "https://github.com/kzzzr/dbtvault.git"
revision: master
warn-unpinned: false
```
Установим модуль командой:
```
dbt deps
```
Cимулируем инкрементальную загрузку данных для TPC-H
----------------------------------------------------
Одно из ключевых преимуществ Data Vault в быстром инкрементальном наполнении детального слоя данных. Из статического датасета TPC-H мы попытаемся симулировать ежедневные инкрементальные пакеты данных, нарезая исходный набор данных по дням.
Всего в TPC-H имеем 4 атрибута с датами:
* ORDERDATE (ORDERS)
* SHIPDATE (LINEITEM)
* RECEIPTDATE (LINEITEM)
* COMMITDATE (LINEITEM)
В большинстве случаев факты идут в хрнологическом порядке: ORDERDATE (заказ), SHIPDATE (отправка), RECEIPTDATE (оплата), COMMITDATE (получение). Минималная дата ORDERDATE в датасете – `1992-01-01`, максимальная – `1998-08-02`. 2405 дней – вполне достаточно, чтобы имитировать инкрементальное историческое наполнение.
В итоге, из 8-ми таблиц исходного TPC-H мы формируем слой `Raw Stage` состоящий из 3-х таблиц:
* raw\_inventory – статический датасет складского учета
* raw\_orders – заказы, которые будем грузить подневно
* raw\_transactions – транзакции к заказам
```
dbt run -m tag:raw
```
Готовим слой Stage
------------------
А теперь давайте приступим к подготовке атрибутов, необходимых для наполнения Data Vault.
* Хэш-суммы для суррогатных ключей и отслеживания изменений
* Переимнование атрибутов
* Константы и метаданные
Для подготовки этого слоя моделей мы воспользуемся макросом `dbtvault.stage()`:
```
{%- set yaml_metadata -%}
source_model: 'raw_transactions'
derived_columns:
RECORD_SOURCE: '!RAW_TRANSACTIONS'
LOAD_DATE: (TRANSACTION_DATE + 1 * INTERVAL '1 day')
EFFECTIVE_FROM: 'TRANSACTION_DATE'
hashed_columns:
TRANSACTION_PK:
- 'CUSTOMER_ID'
- 'TRANSACTION_NUMBER'
CUSTOMER_PK: 'CUSTOMER_ID'
ORDER_PK: 'ORDER_ID'
{%- endset -%}
{% set metadata_dict = fromyaml(yaml_metadata) %}
{% set source_model = metadata_dict['source_model'] %}
{% set derived_columns = metadata_dict['derived_columns'] %}
{% set hashed_columns = metadata_dict['hashed_columns'] %}
{{ dbtvault.stage(include_source_columns=true,
source_model=source_model,
derived_columns=derived_columns,
hashed_columns=hashed_columns,
ranked_columns=none) }}
```
В рамках самого кода модели мы задаем метаданные и передаем в качестве аргументов в макрос:
* Таблица с исходными данными: `source_model`
* Расчетные колонки: `RECORD_SOURCE`, `LOAD_DATE`, `EFFECTIVE_FROM`
* Колонки с хэш-суммой: `TRANSACTION_PK`, `CUSTOMER_PK`, `ORDER_PK`
С кодом самого макроса [stage.sql](https://github.com/Datavault-UK/dbtvault/blob/release/0.7.8/macros/staging/stage.sql) можно ознакомиться в репозитории dbtVault или в папке `./dbt_modules/dbtvault/macros/` нашего dbt-проекта, как и со всеми остальными макросами, которые помогают строить Data Vault. Это и есть те самые шаблоны для кодогенерации.
В результате, к исходным данным добавляется ряд новых и необходимых атрибутов:
 Наполняем Raw Data Vault день за днём
--------------------------------------
Каждая модель типа [hub](https://github.com/Datavault-UK/dbtvault/blob/release/0.7.8/macros/tables/hub.sql), [link](https://github.com/Datavault-UK/dbtvault/blob/release/0.7.8/macros/tables/link.sql), [satellite](https://github.com/Datavault-UK/dbtvault/blob/release/0.7.8/macros/tables/sat.sql) собирается соответствующим макросом. Пример:
```
{%- set source_model = "v_stg_orders" -%}
{%- set src_pk = "CUSTOMER_PK" -%}
{%- set src_nk = "CUSTOMERKEY" -%}
{%- set src_ldts = "LOAD_DATE" -%}
{%- set src_source = "RECORD_SOURCE" -%}
{{ dbtvault.hub(src_pk=src_pk, src_nk=src_nk, src_ldts=src_ldts,
src_source=src_source, source_model=source_model) }}
```
Мы готовы к наполнению нашего детального слоя Data Vault:
```
dbt run -m tag:raw_vault
```
Итого:
* Обработан пакет данных за одни сутки 1992-01-08
* Сформировано 25 моделей за 19 секунд
* Среди них: 7 hubs, 8 links, 11 satellites
Обратите внимание на то, что повторный запуск за те же самые сутки будет выполнен почти мгновенно и вставит 0 записей. Это происхоит потому, что таблицы Data Vault наполняются инкрементально и те записи, которые уже попали в детальный слой, вставлены повторно не будут!
Чтобы загрузить инкремент за следующие сутки, просто поменяйте значение переменной `load_date` в файле `dbt_profiles.yml` на следующий день и запустите загрузку повторно:
```
# dbt_profiles.yml
vars:
load_date: '1992-01-08' # increment by one day '1992-01-09'
```
Дальнейшие шаги
----------------
**1. Посмотрите историю адаптации исходного проекта для нашего демо на Greenplum –** [**commit history**](https://github.com/kzzzr/dbtvault_greenplum_demo/commits/master)**:**
* [eafed95](https://github.com/kzzzr/dbtvault_greenplum_demo/commit/eafed95ad5b912daf9339d877dfa0ee246bd089f) - configure dbt\_project.yml for greenplum
* [aa25600](https://github.com/kzzzr/dbtvault_greenplum_demo/commit/aa2560071b27b2e7f6de924222b7d465e28d8af2) - configure package (adapted dbt\_vault) for greenplum
* [bba7437](https://github.com/kzzzr/dbtvault_greenplum_demo/commit/bba7437a7d29fd5dd9c383bff49c4604fc84d2ab) - configure data sources for greenplum
* [dfc5866](https://github.com/kzzzr/dbtvault_greenplum_demo/commit/dfc5866a63e81393f5bfc0b163cc84b56efc6354) - configure raw layer for greenplum
* [a97a224](https://github.com/kzzzr/dbtvault_greenplum_demo/commit/a97a22431a182e59c9cb8be807200f0292672b0f) - adapt prepared staging layer for greenplum
А также github gist [**Data Vault 2.0 + Greenplum + dbtVault assignment**](https://gist.github.com/kzzzr/4ab36bec6897e48e44e792dc2e706de9).
**2. Изучите документацию проекта, визуальный граф моделей (DAG) в автоматически сгенерированном веб-приложении:**
```
dbt docs generate
dbt docs serve
```
**3. Разберитесь с** [**макросами и кодогенерацией dbtVault**](https://dbtvault.readthedocs.io/en/latest/macros/)
**4. Ознакомьтесь с литературой по теме:**
* [Building a Scalable Data Warehouse with Data Vault 2.0](https://learning.oreilly.com/library/view/building-a-scalable/9780128026489/#)
* [Серия из 4-х статей от Kent Graziano (Snowflake)](https://www.vertabelo.com/authors/kent-graziano/)
* [Pentaho® Kettle Solutions: Chapter 19. Data Vault Management](https://learning.oreilly.com/library/view/pentaho-kettle-solutions/9780470635179/ch19.html)
**5. Приходите на live сессии и вебинары**
Я и мои коллеги стремимся делиться своим лучшим опытом и знаниями в рамках занятий на курсах [**Data Engineer**](https://otus.pw/3F4f/) и [**Analytics Engineer**](https://otus.pw/KHBK/):
* Практики от лидеров отрасли в рамках живого общения
* Ваучер Яндекс.Облака на все эксперименты и задания
* 3 вебинара в [программе](https://docs.google.com/spreadsheets/d/1Bo23j4LG43xE5IBUTP1lQ_RmbJEwLqifP2JVQdO8vf4/edit#gid=1769766247) только по теме Data Vault
* Движуха в Slack и сообщество
Спасибо за внимание! | https://habr.com/ru/post/588582/ | null | ru | null |
# Пользователи жалуются на проблемы с покупками в ваших приложениях? Попробуйте сервис внутриигровых покупок HUAWEI
#### Что мы понимаем под проблемами с покупками в приложениях?
Проблемы с покупками – это когда пользователь не получает приобретенный товар из-за ошибки (например, ошибки соединения) при синхронизации данных между приложением и сервером для покупок в приложении.
Проблемы с покупками наносят ущерб как пользователям, так и разработчикам. В результате приложение получает низкий рейтинг и негативные отзывы в магазине, а разработчик теряет пользователей, включая потенциальных новых пользователей, ведь они даже не попробуют установить ваше приложение. Такой исход, конечно же, крайне нежелателен.
#### К чему обычно приводят сбои при покупках?
Пользователи жалуются, что они оплатили, но не получили покупки и требуют вернуть деньги. В таком случае, ваше приложение потеряет доверие пользователей.
#### Интеграция сервиса HUAWEI IAP решит проблемы с покупками в ваших приложениях
Использование сервиса **HUAWEI IAP** гарантирует пользователю получениеоплаченной покупки.
Приложение использует API сервиса HUAWEI IAP для получения информации о заказе от сервера HUAWEI IAP. Сервер вернет информацию о заказах, которые были оплачены, но не получены через приложение, а затем произойдет повторная доставка продуктов на основании результата запроса. После чего, сервер обновит статус совершения покупки.
Для интеграции сервиса воспользуйтесь следующими инструкциями:
#### HUAWEI IAP: процесс покупки
В случае с оплаченными товарами, приложение вызовет соответствующий API для использования продукта. Если вызов API не удался, доставка продукта не состоится. В случае приобретения нерасходуемых покупок и подписок проблем с доставкой не возникнет.
#### Стандартный процесс приобретения товаров:
1. Пользователь создает запрос на покупку в вашем приложении, а ваше приложение затем направляет этот запрос в HMS Core (APK).
2. Запрос доставки. Проверка подписи в данных о покупке перед доставкой запрошенного продукта.
3. Доставка покупки и отправка токена на сервер вашего приложения. Этот токен используется для получения статуса доставки покупки. Таким образом, вы сможете понять, необходима ли повторная доставка, если при покупке произошла ошибка.
4. После того, как продукт успешно доставлен пользователю, вызовите метод API [consumeOwnedPurchase](https://developer.huawei.com/consumer/en/doc/development/HMSCore-References/iapclient-0000001050137587) для использования продукта и отправки уведомления на сервер Huawei IAP для обновления статуса доставки. Токен **purchaseToken** передается в запросе вызова API и, после того, как покупка использована пользователем, сервер Huawei IAP изменяет статус продукта на «доступно для покупки». После этого продукт можно купить заново.
Кроме метода API [consumeOwnedPurchase](https://developer.huawei.com/consumer/en/doc/development/HMSCore-References/iapclient-0000001050137587), предоставленного IAP клиентом, ваше приложение также может воспользоваться API от IAP сервера для использования продукта. Чтобы узнать об этом более подробно, смотрите раздел [Подтверждение покупки для сервиса заказов](https://developer.huawei.com/consumer/en/doc/development/HMSCore-Guides/purchase-confirm-for-order-service-0000001050035031).
#### Как HUAWEI IAP осуществляет повторную доставку продукта
HUAWEI IAP поможет вам повторно доставить расходуемую покупку при сбоях доставки, которые возникли из-запроблем с синхронизацией данных (ошибки соединения, завершение процесса и др.) между вашим приложением и сервером IAP. На рисунке показан процесс доставки.
**Ваше приложение требует активации повторной доставки в следующих случаях:**
* Запуск приложения.
* Код результата **-1** (OrderStatusCode. ORDER\_STATE\_FAILED) вернулся в ответ на запрос о покупке.
* Код результата **60051** (OrderStatusCode. ORDER\_PRODUCT\_OWNED) вернулся в ответ на запрос о покупке.
**Функция повторной доставки реализуется следующим образом:**
Шаг 1. Используйте [obtainOwnedPurchases](https://developer.huawei.com/consumer/en/doc/development/HMSCore-References/iapclient-0000001050137587) для получения информации о покупке для оплаченных, но не доставленных товаров. Укажите **priceType** равный **0** в [OwnedPurchasesReq](https://developer.huawei.com/consumer/en/doc/development/HMSCore-References/ownedpurchasesreq-0000001050135762).
Если вызов API прошел успешно, HUAWEI IAP вернет объект [OwnedPurchasesResult](https://developer.huawei.com/consumer/en/doc/development/HMSCore-References/ownedpurchasesreq-0000001050135762), содержащий данные о покупке и подписи по всем приобретенным, но не доставленным продуктам. Используйте публичный ключ в AppGallery Connect для проверки подписи. Подробную информацию о способе проверки можно найти в разделе «[Проверка подписи при возвращении результата](https://developer.huawei.com/consumer/en/doc/development/HMSCore-Guides/verifying-signature-returned-result-0000001050033088)».
Данные о каждой покупке представляют собой строку символов в формате JSON, которая содержит параметры, указанные в [InAppPurchaseData](https://developer.huawei.com/consumer/en/doc/development/HMSCore-References/json-inapppurchasedata-0000001050986125). Вам нужно распарсить поле **purchaseState** из строки символов **InAppPurchaseData**. Если **purchaseState** покупки равен **0** - то покупка успешно состоялась и доставка будет выполнена.
```
// Создайте объект OwnedPurchasesReq.
OwnedPurchasesReq ownedPurchasesReq = new OwnedPurchasesReq();
// priceType: 0: расходуемая покупка; 1: нерасходуемая покупка; 2: подписка
ownedPurchasesReq.setPriceType(0);
// Получите объект Activity, вызывающий API.
final Activity activity = getActivity();
// Вызовите API obtainOwnedPurchases для получения информации о заказе по всем расходуемым покупкам, которые были приобретены, но не доставлены.
Task task = Iap.getIapClient(activity).obtainOwnedPurchases(ownedPurchasesReq);
task.addOnSuccessListener(new OnSuccessListener() {
@Override
public void onSuccess(OwnedPurchasesResult result) {
// Получите результат выполнения при успешном запросе.
if (result != null && result.getInAppPurchaseDataList() != null) {
for (int i = 0; i < result.getInAppPurchaseDataList().size(); i++) {
String inAppPurchaseData = result.getInAppPurchaseDataList().get(i);
String inAppSignature = result.getInAppSignature().get(i);
// Используйте публичный ключ IAP для проверки подписи inAppPurchaseData.
// Проверьте статус покупки каждого продукта, если проверка прошла успешно. После совершения платежа, доставьте необходимый продукт пользователю. После успешной доставки используйте продукт.
try {
InAppPurchaseData inAppPurchaseDataBean = new InAppPurchaseData(inAppPurchaseData);
Int purchaseState = inAppPurchaseDataBean.getPurchaseState();
} catch (JSONException e) {
}
}
}
}
}).addOnFailureListener(new OnFailureListener() {
@Override
public void onFailure(Exception e) {
if (e instanceof IapApiException) {
IapApiException apiException = (IapApiException) e;
Status status = apiException.getStatus();
Int returnCode = apiException.getStatusCode();
} else {
// Другие внешние ошибки.
}
}
});
```
Шаг 2. Вызовите метод API consumeOwnedPurchase для использования доставленного продукта.
Шаг 3. Подтвердите доставку для всех запрошенных продуктов через метод API [obtainOwnedPurchases](#ZH-CN_TOPIC_0000001050137587__section15126153542812). Если продукт уже доставлен, вызовите метод API [consumeOwnedPurchase](#ZH-CN_TOPIC_0000001050137587__section16784102213346) для использования продукта и дайте инструкцию серверу Huawei IAP для обновления статуса доставки. После использования продукта, сервер Huawei IAP изменяет статус продукта на «доступно для покупки», позволяя купить его снова.
Для получения более подробной информации перейдите по ссылкам:
[**HUAWEI IAP: официальный сайт**](https://developer.huawei.com/consumer/ru/hms/huawei-iap/?ha_source=hms1)
[**HUAWEI IAP: информация для разработчиков**](https://developer.huawei.com/consumer/en/doc/development/HMSCore-Guides/introduction-0000001050033062)
[**Сообщество HUAWEI HMS Core**](https://developer.huawei.com/consumer/en/forum/block/hms-core?ha_source=hms1)
Адреса репозиториев с открытым исходным кодом с образцами интеграции HMS: [GitHub](https://github.com/HMS-Core) и [Gitee](https://gitee.com/hms-core)
Подпишитесь на нас, чтобы получать информацию о новейших технологиях HMS. | https://habr.com/ru/post/574550/ | null | ru | null |
# Komodo Edit: сборка deb-пакета
Доброго времени суток, хабравчане.
Я уже довольно давно пользуюсь замечательным редактором [Komodo Edit](http://www.activestate.com/komodo-edit) (в принципе, можно его отнести даже к IDE). Когда в 2007-2008 году стал использовать Debian в качестве десктопной ОС, то для разработки продолжил использование Komodo Edit, хотя иногда кидался к Eclipse, но как-то окончательно настроив Komodo Edit, успокоился, так как он меня полностью устраивает в качестве IDE для веб-разработки. Примерно в то же время написал bash-скрипт для сборки deb-пакета, так как дружу с пакетной системой Debian'а.
Данный скрипт также имеет help и может быть использован в Ubuntu и других deb-based дистрибутивах.
Собственно, сам скрипт (прошу прощения за использование английского в комментариях к коду, лень переписывать на русские, а для использования это ни к чему):
```
#!/bin/bash
################################################################################
# #
# This script makes Komodo Edit package for Debian #
# #
################################################################################
# backup IFS variable
OLD_IFS=$IFS
UMASK=`umask`
# the archive filename
archive_name=""
# Package version number
VERSION=""
# Package revision number
REVISION=""
# package Architecture
ARCH=""
# Where we are now :)
FULL_PATH=`pwd`
# temporary subfolder
TEMP_PATH="temp-komodo-pkg"
# Full extract path
EXTR_PATH=$FULL_PATH/$TEMP_PATH
# Installation script
SCRIPT="install.sh"
# temporary installation path
TEMP_BUILD_PATH="$EXTR_PATH/temp-build"
# real installation path
BUILD_PATH="$EXTR_PATH/build"
# installation prefix
PREFIX=usr
# delete temporary files
opt_del_temp="1"
# Make submenu Komodo Edit in Development Menu
opt_submenu=""
# Size for Pixmaps Icon
pixmaps_size="48x48"
# show script usage
usage()
{
cat << EOF
Usage:
`basename $0` [options] [filename]
This script makes Debian/Ubuntu package for Komodo Edit.
The filename is Komodo Edit tar.gz-file.
Options:
-h | --help View this message
-u Make Ubuntu package (by default packaging for Debain)
-m Make menu subfolder entry
-s Save temporary files (temp-komodo-pkg folder)
EOF
}
# options parser for check_args function
option_parse()
{
# Unexpected argument?
arg=`expr match "$1" ".*\([^-hums]\)"`
if [ -n "$arg" ]; then
echo "There is unexpected option specified. Exit."
usage
exit 2
fi
# SHow help?
arg=`expr match "$1" ".*\([h]\)"`
if [ -n "$arg" ]; then
usage
exit 0
fi
# Save temprary?
arg=`expr match "$1" ".*\([s]\)"`
if [ -n "$arg" ]; then
opt_del_temp=""
fi
# Submenu for Komodo?
arg=`expr match "$1" ".*\([m]\)"`
if [ `expr match "$1" ".*\([m]\)"` ]; then
opt_submenu="1"
fi
# Ubuntu package?
arg=`expr match "$1" ".*\([u]\)"`
if [ -n "$arg" ]; then
PREFIX=usr/local
REVISION="-ubuntu0"
fi
}
# check input arguments
check_args()
{
if [ -z "$1" ]; then
echo "There is no arguments specified. Exit."
usage
exit 1
fi
for arg in $@
do
case $arg in
--help) option_parse -h;;
-[a-z]*) options=`expr match "$arg" "\(-[a-z]*\)"`
option_parse $options;;
*) options=`expr match "$arg" "\(.*\.tar\.gz\)"`
if [ -z "$options" ]; then
echo "There is unexpected argument \"$arg\" specified. Exit."
usage
exit 2
elif [ -f "$options" ]; then
if [ -n "$archive_name" ]; then
echo "Too many filenames specified. Exit."
usage
exit 3
fi
archive_name=$options
else
echo "The specified argument \"$options\" is not a file. Exit."
usage
exit 4
fi;;
esac
done
}
# check the system functionality
check_funcs()
{
CONVERTER=`which convert`
echo -n "Checking for image converter ..."
if [ -z "$CONVERTER" ]; then
echo "Error"
echo "Please install converter for images (can be found in package imagemagick). Exit."
exit 5
fi
echo "Found"
FAKEROOT=`which fakeroot`
echo -n "Checking for fakeroot ..."
if [ -z "$FAKEROOT" ]; then
echo "Error"
echo "Please install package fakeroot. Exit."
exit 5
fi
echo "Found"
}
# Package name parser
package_name_parse()
{
if [ -z "$1" ]; then
echo "There is no Komodo Edit archive file specified. Exit."
usage
exit 6
else
echo "The specified file \"$1\" found."
fi
name=`basename $1`
IFS="-"
name=( $name )
VERSION=${name[2]}
REVISION=${name[3]}$REVISION
ARCH=${name[6]}
IFS="."
ARCH=( $ARCH )
ARCH=${ARCH[0]}
# restore IFS variable
IFS=$OLD_IFS
if [ "$ARCH" == "x86" ]; then
ARCH="i386"
elif [ "$ARCH" == "x86_64" ]; then
ARCH="amd64"
fi
echo "Version: $VERSION"
echo "Revision: $REVISION"
echo "Architecture: $ARCH"
}
unpack_archive()
{
umask 022
echo -n "Clean old temporary files ..."
rm -rf $EXTR_PATH
mkdir $EXTR_PATH
echo "Done"
echo -n "Unpack Komodo Edit tarball file to $EXTR_PATH ..."
tar -xvf $1 -C $EXTR_PATH > /dev/null
if [ "$?" != 0 ]; then
umask $UMASK
exit 5
fi
echo "Done"
SCRIPT=$EXTR_PATH/`ls $EXTR_PATH`/$SCRIPT
mkdir "$TEMP_BUILD_PATH"
mkdir "$BUILD_PATH"
umask $UMASK
}
install_komodo()
{
umask 022
$SCRIPT -I "$TEMP_BUILD_PATH/$PREFIX" -s
umask $UMASK
}
# precompile some python scripts at lib/mozilla subfolder
# and change start komodo script
prepare_komodo()
{
umask 022
echo "Preparing Komodo scripts ..."
$TEMP_BUILD_PATH/$PREFIX/lib/python/bin/python -O -mcompileall $TEMP_BUILD_PATH/$PREFIX/lib/mozilla/
sed -i -e 's/$INSTALLDIR\/lib/$INSTALLDIR\/share\/komodo-edit\/lib/i' $TEMP_BUILD_PATH/$PREFIX/bin/komodo
echo "Scripts preparing done."
umask $UMASK
}
mv_package_files()
{
umask 022
mkdir -p $BUILD_PATH/$PREFIX/bin
mkdir -p $BUILD_PATH/$PREFIX/share/komodo-edit/lib
mkdir -p $BUILD_PATH/$PREFIX/share/komodo-edit/doc
echo -n "Moving files for package. Please wait ..."
# Move main script
mv $TEMP_BUILD_PATH/$PREFIX/bin/* $BUILD_PATH/$PREFIX/bin/
# Move all libs
mv $TEMP_BUILD_PATH/$PREFIX/lib/* $BUILD_PATH/$PREFIX/share/komodo-edit/lib/
# Move docs
mv $TEMP_BUILD_PATH/$PREFIX/share/doc/* $BUILD_PATH/$PREFIX/share/komodo-edit/doc/
mv $TEMP_BUILD_PATH/$PREFIX/share/doc/.css $BUILD_PATH/$PREFIX/share/komodo-edit/doc/
echo "Done"
umask $UMASK
}
make_icons()
{
umask 022
echo -n "Creating icons ..."
SIZES="64x64 48x48 32x32 24x24 22x22 16x16"
mkdir -p $BUILD_PATH/$PREFIX/share/icons/hicolor/128x128/apps
cp -p $TEMP_BUILD_PATH/$PREFIX/share/icons/komodo128.png $BUILD_PATH/$PREFIX/share/icons/hicolor/128x128/apps/komodo.png
WORK_PATH=$BUILD_PATH/$PREFIX/share/icons/hicolor
for size in $SIZES
do
mkdir -p $WORK_PATH/$size/apps
$CONVERTER $WORK_PATH/128x128/apps/komodo.png -resize $size $WORK_PATH/$size/apps/komodo.png
done
mkdir -p $BUILD_PATH/usr/share/pixmaps
cp $BUILD_PATH/$PREFIX/share/icons/hicolor/$pixmaps_size/apps/komodo.png $BUILD_PATH/usr/share/pixmaps/
echo "Done"
umask $UMASK
}
make_menu_entries()
{
umask 022
echo -n "Make menu entries ..."
mkdir -p $BUILD_PATH/usr/share/menu
filename=$BUILD_PATH/usr/share/menu/komodo-edit
echo "?package(komodo-edit):needs=\"x11\" section=\"Apps/Programming\" \ " > $filename
echo " title=\"Komodo Edit\" command=\"/$PREFIX/bin/komodo %F\" \ " >> $filename
echo " icon=\"/usr/share/pixmaps/komodo.png\" " >> $filename
echo "" >> $filename
if [ -z "$opt_submenu" ]; then
echo "Done"
category="Development;"
depends=""
umask $UMASK
return
fi
category="Komodo;"
depends="xdg-utils"
mkdir -p $BUILD_PATH/etc/xdg/menus/applications-merged
filename=$BUILD_PATH/etc/xdg/menus/applications-merged/komodo-edit.menu
echo ' $filename
echo '"http://www.freedesktop.org/standards/menu-spec/menu-1.0.dtd">' >> $filename
echo '' >> $filename
echo ' Applications' >> $filename
echo ' ' >> $filename
echo ' Development' >> $filename
echo ' ' >> $filename
echo ' Komodo' >> $filename
echo ' komodoedit.directory' >> $filename
echo ' ' >> $filename
echo ' Komodo' >> $filename
echo ' ' >> $filename
echo ' ' >> $filename
echo ' ' >> $filename
echo '' >> $filename
mkdir -p $BUILD_PATH/usr/share/desktop-directories
filename=$BUILD_PATH/usr/share/desktop-directories/komodoedit.directory
echo '[Desktop Entry]' > $filename
echo 'Encoding=UTF-8' >> $filename
echo 'Type=Directory' >> $filename
echo 'Name=Komodo Edit' >> $filename
echo 'Icon=komodo' >> $filename
echo "Done"
umask $UMASK
}
make_desktop_files()
{
umask 022
echo -n "Make desktop files ..."
mkdir -p $BUILD_PATH/usr/share/applications
filename=$BUILD_PATH/usr/share/applications/komodo-edit.desktop
echo '[Desktop Entry]' > $filename
echo 'Type=Application' >> $filename
echo 'Name=Komodo Edit' >> $filename
echo 'Encoding=UTF-8' >> $filename
echo 'Icon=komodo' >> $filename
echo 'Exec=komodo %F' >> $filename
echo "Categories=$category" >> $filename
echo 'Terminal=false' >> $filename
echo 'Comment=Dynamic Languages Web-Editor' >> $filename
echo 'GenericName=Dynamic Web-pages Editor' >> $filename
if [ -z "$opt_submenu" ]; then
echo "Done"
umask $UMASK
return
fi
filename=$BUILD_PATH/usr/share/applications/komodo-license.desktop
echo '[Desktop Entry]' > $filename
echo 'Type=Application' >> $filename
echo 'Name=License' >> $filename
echo 'Encoding=UTF-8' >> $filename
echo 'Icon=txt' >> $filename
echo "Exec=xdg-open /$PREFIX/share/komodo-edit/doc/license.txt" >> $filename
echo "Categories=$category" >> $filename
echo 'Terminal=false' >> $filename
filename=$BUILD_PATH/usr/share/applications/komodo-relnotes.desktop
echo '[Desktop Entry]' > $filename
echo 'Type=Application' >> $filename
echo 'Name=Release Notes' >> $filename
echo 'Encoding=UTF-8' >> $filename
echo 'Icon=html' >> $filename
echo "Exec=xdg-open /$PREFIX/share/komodo-edit/doc/relnotes.html" >> $filename
echo "Categories=$category" >> $filename
echo 'Terminal=false' >> $filename
echo "Done"
umask $UMASK
}
make_control_file()
{
umask 022
echo -n "Make Debian control file ..."
mkdir -p $BUILD_PATH/DEBIAN
#calculate installed size
full_size=`du -s $BUILD_PATH/usr | awk '{print $1}'`
filename=$BUILD_PATH/DEBIAN/control
echo "Package: komodo-edit" > $filename
echo "Version: $VERSION-$REVISION" >> $filename
echo "Architecture: $ARCH" >> $filename
echo "Section: web" >> $filename
echo "Priority: optional" >> $filename
echo "Installed-Size: $full_size" >> $filename
if [ -n "$depends" ]; then
echo "Depends: $depends" >> $filename
fi
echo "Homepage: www.activestate.com" >> $filename
echo "Maintainer: KernelPanic :) " >> $filename
echo "Description: Komodo Edit is a free, open source editor from dynamic language experts." >> $filename
echo " Komodo Edit, based on the award-winning Komodo IDE, offers sophisticated support" >> $filename
echo " for all major scripting languages, including in-depth autocomplete and calltips, " >> $filename
echo " multi-language file support, syntax coloring and syntax checking, Vi emulation, " >> $filename
echo " Emacs key bindings." >> $filename
echo " It provides dynamic language expertise for Perl, PHP, Python, Ruby, and Tcl, plus JavaScript, " >> $filename
echo " CSS, HTML, and XML, and template languages like RHTML, Template-Toolkit, HTML-Smarty " >> $filename
echo " and Django." >> $filename
echo "Done"
umask $UMASK
}
make\_package()
{
fakeroot dpkg-deb -b $BUILD\_PATH ./
}
del\_temporary()
{
if [ -n "$opt\_del\_temp" ]; then
echo -n "Delete temporary files and directories ..."
rm -rf $EXTR\_PATH
echo "Done"
else
rm -rf $TEMP\_BUILD\_PATH
echo "Temporary files may be found at temp-komodo-pkg/ folder"
fi
}
check\_args $@
package\_name\_parse $archive\_name
check\_funcs
unpack\_archive $archive\_name
install\_komodo
prepare\_komodo
mv\_package\_files
make\_icons
make\_menu\_entries
make\_desktop\_files
make\_control\_file
make\_package
del\_temporary
echo "All Done. Package is ready :)"
exit 0
```
Ход работы скрипта:
1) парсинг имени архива вида Komodo-Edit-#VERSION-#REVISION-linux-libcpp6-#ARCH.tar.gz откуда получаем всю нужную информацию;
2) распаковка архива во временную папку;
3) установка Komodo Edit туда;
4) прекомпилирование исходников;
5) рассовывание файлов в нужные подпапки;
6) создание control файла;
7) сборка deb-пакета с использованием fakeroot;
Использование:
0) сделать файл со скриптом исполняемым
1) кинуть скрипт (у меня называется mkpkg-komodo) в /usr/local/bin
2) скачать архив с [activestate.com](http://www.activestate.com/komodo-edit/downloads)
3) запустить скрипт с нужными параметрами (посмотрите help, кому нужно, мне хватает просто имени файла с архивом):
`$ mkpkg-komodo Komodo-Edit-6.1.3-8844-linux-libcpp6-x86_64.tar.gz`
4) установите получившийся deb-пакет:
`# dpkg -i komodo-edit_6.1.3-8844_amd64.deb`
Можно также добавить в локальный репозиторий, копировать свой топик про создание репозитория не буду, кому интересно, [гляньте](http://unixforum.org/index.php?showtopic=79513).
В разделе Разработка (Developement) меню появится пункт Komodo Edit.
Чтобы сделать Komodo Edit более полноценной IDE установите плагин [NST](http://community.activestate.com/xpi/nst-new-source-tree)
Как это выглядит:
*UPD*: В принципе, скрипт предупредит вас, если не будут установлены пакеты imagemagick и fakeroot, надо поставить:
`# aptitude install imagemagick fakeroot` | https://habr.com/ru/post/133484/ | null | ru | null |
# Deb.js: самый крохотный отладчик в мире
Перевод статьи «Deb.js: the Tiniest Debugger in the World», Krasimir Tsonev
Мы, как разработчики, пишем код. Но мы не просто пишем код, мы также проверяем, работает ли написанный нами код. Мы тратим много времени и усилий, чтобы удостовериться, что наши программы делают то что долны делать. процесс отладки зачастую бывает болезненным. Особенно, если мы не используем подходящие инструменты. Чтобы справиться с данной проблемой, сегодняшняя заметка представляет [Deb.js](https://github.com/krasimir/deb.js), маленькую JavaScript библиотеку, которая помогает при отладке в браузере.
#### Пример
Начнем с создания маленькой страницы с небольшим JavaScript взаимодействием. Мы создадим форму с двумя полями и кнопкой. По нажатии кнопки мы будем будем собирать данные и выводить сообщение в консоль. Вот и разметка страницы:
```
Name:
Address:
```
Чтобы упростить пример, мы будем использовать jQuery для DOM выборок и событий. Мы обернем функциональность в следующий модуль:
```
var Module = {
collectData: function(cb) {
var name = $('[name="name"]').val();
var address = $('[name="address"]').val();
if(name != '' && address != '') {
cb(null, { name: name, address: address });
} else {
cb({msg: 'Missing data'});
}
},
error: function(err) {
$('[data-element="output"]').html(err.msg);
},
success: function(data) {
$('[data-element="output"]').html('Hello ' + data.name + '!');
}
}
```
Функция `collectData` собирает значения с полей и проверяет, не ввел ли пользователь чего-нибудь. Если нет, то происходит обратный вызов с переданным объектом, содержащим короткое сообщение об ошибке. Если все в порядке, функция отвечает с null в первом аргументе и объектом, содержащим данные, как второй параметр. Разработчик, использующий модуль, должен проверять, передан ли объект ошибки. Если ошибка не передана, тогда можно использовать второй переданный аргумент. Например:
```
$('[value="register"]').on('click', function() {
Module.collectData(function(err, data) {
if(typeof err === 'object') {
Module.error(err);
} else {
Module.success(data);
}
});
});
```
Мы проверяем, является ли параметр `err` объектом и если да, то показываем сообщение об ошибке. Если присмотреться к коду, то можно обнаружить проблему, но давайте пока посмотрим, как все работает:
Если данные не введены, наш скрипт работает как и ожидалось. Под формой показывается сообщение о том, что данные не введены. В то же время, Если мы заполним поля и нажмем кнопку, то получим сообщение:
> Uncaught TypeError: Cannot read property 'msg' of null
Давайте же выследим и исправим эту ошибку.
#### Традиционный подход
В Google Chrome есть замечательные инструменты для решения таких проблем. Мы можем кликнуть по ошибке и увидеть ее стэктрейс. Можем даже перейти к месту, где ошибка была произведена.
Похоже что метод `error` из нашего модуля получает что-то, что является `null`. И конечно же, `null` не имеет свойства `msg`. Вот почему браузер выбрасывает ошибку. Функция `error` вызывается только в одном месте. Давайте поставим точку останова и посмотрим, что происходит:
Похоже что мы получаем правильный объект `data` и `error` равен `null`, и это правильное поведение. Таким образом, проблема должна быть где-то в `if` предложении. Добавим `console.log` и увидим, движемся ли мы в правильном направлении:
```
Module.collectData(function(err, data) {
console.log(typeof err);
if(typeof err === 'object') {
Module.error(err);
} else {
Module.success(data);
}
});
```
И в самом деле, `typeof err` возвращает `object`. Вот почему мы всегда показываем ошибку.
И вуаля, мы нашли проблему. Нам, всего-то, нужно изменить конструкцию `if` на `if (err)` и наш маленький эксперимент будет работать, как ожидалось.
Тем не менее, иногда такой подход может быть довольно утомительным по следующим причинам:
* Как вы видели, мы прибегли к логированию переменной. Так что не всегда можно обойтись установкой точки останова. Мы также должны переходить в консоль. В то же время, мы должны смотреть в редактор кода и в панель отладки Chrome. Это несколько мест, где нужно работать, что может быстро наскучить.
* Если у нас много данных залогировано в консоли, это тоже может стать проблемой. Временами, может быть трудно найти нужную информацию.
* Также этот подход не поможет, если у нас есть проблемы с производительность. Чаще всего, нам нужно знать время выполнения.
Иметь возможность остановить выполнение программы и посмотреть её состояние — бесценно, но Chrome не может знать, что именно мы хотим увидеть. Как в нашем случае, мы должны дважды проверять конструкцию `if`. Не было бы лучше, если бы у нас был инструмент доступный напрямую из нашего кода? Библиотека, которая предоставляет такую же информацию, что и отладчик, но находится внутри консоли? Так вот, [Deb.js](https://github.com/krasimir/deb.js) и есть ответ на этот вопрос.
#### Используем Deb.js
[Deb.js](https://github.com/krasimir/deb.js) это маленький кусочек JavaScript кода, 1,5кб в минифицированном виде, который отправляет информацию в консоль. Он может быть присоединен к любой функции и выводит:
* Время и место выполнения функции
* Трассировку стека
* Отформатированный и сгруппированный возврат
Давайте взглянем, как выглядит наш пример при использовании Deb.js:
Мы, в точности, видим переданные аргументы и трассировку стека. Но заметьте изменения в консоли. Мы работаем над нашим кодом, находим, где может находиться проблема и добавляем `.deb()` после определения функции. Заметьте, что тип `err` помещен внутри функции. Таким образом, нам не нужно это искать. Возврат также сгруппирован и раскрашен. Каждая функция, которую мы отлаживаем будет напечатана отдельным цветом. Давайте исправим наш ошибку и поместим другой `deb()`, чтобы увидеть, как это выглядит.
Теперь у нас есть две функции. Мы можем запросто различить их, так как они окрашены в разные цвета. Мы видим их параметры, вывод и время выполнения. Если в функции есть инструкции `console.log`, мы увидим их внутри функции, на месте где они происходят. Есть даже возможность оставлять описание функций, для лучшего их распознавания.
Заметьте, что мы использовали `debc`, а не `deb`. Это та же функция, только со свернутым выводом. Если вы начнете использовать [Deb.js](https://github.com/krasimir/deb.js), вы очень быстро заметите, что вам не всегда нужно видеть все подробности.
#### Как был придуман Deb.js
Изначальная идея была изложена в статье[Реми Шарпа(Remy Sharp)](https://twitter.com/rem) о нахождении вызовов `console.log`. Он предлагал создавать новую ошибку и получать оттуда трассировку:
```
['log', 'warn'].forEach(function(method) {
var old = console[method];
console[method] = function() {
var stack = (new Error()).stack.split(/\n/);
// Chrome includes a single "Error" line, FF doesn't.
if (stack[0].indexOf('Error') === 0) {
stack = stack.slice(1);
}
var args = [].slice.apply(arguments).concat([stack[1].trim()]);
return old.apply(console, args);
};
})
```
Оригинал статьи можно найти [в блоге Реми](http://remysharp.com/2014/05/23/where-is-that-console-log/). Это особенно полезно, если мы пишем в окружении Node.js.
Итак, имея трассировку стека, мне как-то нужно было внедрить код в начало и конец функции. Тогда-то мне вспомнился паттерн использованный в [вычисляемых свойствах Ember'а](http://emberjs.com/guides/object-model/computed-properties/). Это хороший способ, запатчить `Function.prototype`. Например:
```
Function.prototype.awesome = function() {
var original = this;
return function() {
console.log('before');
var args = Array.prototype.slice.call(arguments, 0);
var res = original.apply(this, args);
console.log('after');
return res;
}
}
var doSomething = function(value) {
return value * 2;
}.awesome();
console.log(doSomething(42));
```
Ключевое слово `this` в нашем методе, указывает на базовый класс функции. Мы можем вызывать метод, к которому мы подключаемся, позже, когда нам это потребуется, это именно то, что нам нужно, так как мы можем отслеживать время до и после выполнения. В то же время мы возвращаем нашу собственную функцию, которая теперь работает, как прокси. Мы использовали `.apply(this, args)` для того, чтобы сохранить контекст и переданные аргументы. И благодаря подсказке Реми, мы также можем получить трассировку стека.
Остальная часть реализации [Deb.js](https://github.com/krasimir/deb.js) это просто декорация. Некоторые браузеры поддерживают `console.group` и `console.groupEnd`, которые намного улучшают визуальное отображение при логировании. Chrome даже позволяет нам раскрашивать отображаемую информацию в разные цвета.
#### Итог
Я верю в использование отличных инструментов. Браузеры это умные инструменты, разработанные умными людьми, но иногда нам нужно нечто большее. [Deb.js](https://github.com/krasimir/deb.js) появился, как крошечная утилита и успешно помогла ускорить мне процесс отладки. Это, конечно же, опенсорсная библиотека. Не стесняйтесь [создавать issues и pull request'ы](https://github.com/krasimir/deb.js).
Спасибо за внимание. | https://habr.com/ru/post/228819/ | null | ru | null |
# Хабр, давай пофиксим письма?
Привет.
В очередной раз получив письмо от хабра, я расстроился. А дело вот в чем. На скриншоте слева мы видим нормальное адаптированное письмо. Так оно отображается во всех вменяемых мобильных почтовых клиентах, которые поддерживают media queries. Теперь давайте взглянем на скрин справа. Таким письмо мы видим в мобильных Gmail, Yandex, Mail.ru клиентах как на андроиде, так и на яблочке. Как вы уже возможно догадались, эти клиенты media queries не поддерживают.
В случае с хабром задача проста до боли. Нам нужно отказаться от медиазапросов в пользу банальной резиновой верстки с кусочками магии. Давайте представим, что текущее письмо хабра — это #NEWSLETTER# для упрощения восприятия кода.
Прежде всего рассмотрим обертку письма в ее текущем виде:
```
| |
| --- |
|
#NEWSLETTER#
|
```
Давайте избавимся от мусора:
```
| |
| --- |
|
#NEWSLETTER#
|
```
Уже намного лучше. А теперь давайте сделаем обертку адаптивной:
```
body { margin:0; }
@media only screen and (min-width: 600px) {
.wrapper { width:600px !important; }
/\* устанавливаем ширину обертки в 600px для десктопов, которые поддерживают медиазапросы \*/
}
| |
| --- |
|
#NEWSLETTER#
|
```
Вот и все. Какую выгоду мы из этого извлекли: письмо адаптировано под все мобильные почтовые клиенты без исключения, единственное за чем необходимо следить — это отсутствие внутри обертки элементов, которые превышают 280px(300 минус 10\*2px отступ обертки) по своей ширине. Внутри только резина. А так же для каждого текстового блока должна быть div обертка с форматированием текста.
Тем не менее во всей этой схеме есть один маленький косяк. the Bat! не поддерживает max-width, хаки, вынесенные стили и медиазапросы. Поэтому в этом почтовике наше письмо будет во всю ширину почтовика. Согласитесь, это небольшая жертва по сравнению с адаптацией трех мобильных клиентов? Тем не менее, если вдруг кто нибудь предложит рабочее решение, получит от меня бонус.
Субъективный пост скриптум: размер шрифта в письме слишком большой. На десктопах выглядит нормально, но на смартфоне отжирается уйма свободного места. Достаточно уменьшить размер заголовков топиков до 16px и будет конфетка. Прилагаю скрин десктопной версии письма для тех, кто не в курсе как оно выглядит.
 | https://habr.com/ru/post/258317/ | null | ru | null |
# Генерация фиктивных данных с Mimesis: Часть I
**Mimesis** — это библиотека для языка программирования Python, которая помогает генерировать фиктивные данные для различных целей. Библиотека написана с использованием средств, включенных в стандартную библиотеку языка Python, потому не имеет никаких сторонних зависимостей. На данный момент библиотека поддерживает 30 языковых стандартов (в числе которых и русский) и более 20 классов-провайдеров, предоставляющих разного рода данные.
Возможность генерировать фиктивные, но в то же время валидные данные бывает очень полезна при разработке приложений, которые подразумевают работу с базой данных. Ручное заполнение базы данных представляется довольно затратным по времени и трудоемким процессом, который выполняется как минимум в 3 этапа — это:
1. Сбор необходимой информации.
2. Постобработка собранных данных.
3. Программирования генераторов данных.
Эта непростая задача по-настоящему усложняется в тот момент, когда требуется сгенерировать не 10-15 пользователей, а 100-150 тысяч пользователей (или иного рода данные). В этой и двух последующих статьях мы постараемся обратить ваше внимание на инструмент, который в разы упрощает процесс генерации тестовых данных, начальной загрузки базы данных и тестирования в целом.
### Общая информация
Поддерживаемые языковые стандарты:
| № | Код | Название |
| --- | --- | --- |
| 1 | `cs` | Чешский |
| 2 | `da` | Датский |
| 3 | `de` | Немецкий |
| 4 | `de-at` | Австрийский немецкий |
| 5 | `de-ch` | Швейцарский немецкий |
| 6 | `en` | Английский |
| 7 | `en-au` | Австралийский английский |
| 8 | `en-ca` | Канадский английский |
| 9 | `en-gb` | Британский английский |
| 10 | `es` | Испанский |
| 11 | `es-mx` | Мексиканский испанский |
| 12 | `fa` | Персидский (Фарси) |
| 13 | `fi` | Финский |
| 14 | `fr` | Французский |
| 15 | `hu` | Венгерский |
| 16 | `is` | Исландский |
| 17 | `it` | Итальянский |
| 18 | `ja` | Японский |
| 19 | `ko` | Корейский |
| 20 | `nl` | Нидерландский |
| 21 | `nl-be` | Бельгийский нидерландский |
| 22 | `no` | Норвежский |
| 23 | `pl` | Польский |
| 24 | `pt` | Португальский |
| 25 | `pt-br` | Бразильский португальский |
| 26 | `ru` | Русский |
| 27 | `sv` | Шведский |
| 28 | `tr` | Турецкий |
| 29 | `uk` | Украинский |
| 30 | `zh` | Китайский |
Список поддерживаемых классов-провайдеров постоянно расширяется. Все поддерживаемы поставщики данных перечислены [тут](https://github.com/lk-geimfari/mimesis/blob/master/PROVIDERS.md).
Помимо перечисленных выше, поддерживаются так же специфичные для конкретных стран данные, которые можно импортировать из подпакета `builtins`:
| № | Провайдер | Методы |
| --- | --- | --- |
| 1 | USASpecProvider | *tracking\_number(), ssn(), personality()* |
| 2 | JapanSpecProvider | *full\_to\_half(), half\_to\_full()* |
| 2 | RussiaSpecProvider | *patronymic(), passport\_series(), passport\_number(), snils()* |
| 2 | BrazilSpecProvider | *cpf(), cnpj()* |
### Установка
Установка `Mimesis` производится как обычно, т.е посредством пакетного менеджера `pip`. Чтобы установить последнюю свежую версию библиотеки выполните следующую команду:
```
➜ ~ pip install mimesis
```
Если по каким-то причинам у вас не получается установить пакет с помощью `pip`, то попробуйте установить его вручную, как показано ниже:
```
(venv) ➜ git clone https://github.com/lk-geimfari/mimesis.git
(venv) ➜ cd mimesis/
(venv) ➜ python3 setup.py install
# или
(venv) ➜ make install
```
**Обращаем** ваше внимание, что библиотека работает только на `Python 3.5 +`. Никаких планов по добавлению поддержки `Python 2.7` у разработчиков нет.
### Генерация
Изначально мы планировали показать генерацию данных на примере небольшого веб-приложения на Flask, но решили отказаться от этой идеи, по той причине, что не все знакомы с Flask и не все горят желанием это исправлять. Потому мы будем показывать все на чистом Python. В случае, если вы захотите перенести все в свой проект на Flask или Django, то вам нужно всего лишь определить статический метод, выполняющий все манипуляции связанные с текущей моделью и вызывать его в тот момент, когда нужно выполнить начальную загрузку БД, как показано в примере ниже.
Модель для Flask (`Flask-SQLAlchemy`) будет выглядеть как-то так:
```
class Patient(db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(120), unique=True)
phone_number = db.Column(db.String(25))
full_name = db.Column(db.String(100))
weight = db.Column(db.String(64))
height = db.Column(db.String(64))
blood_type = db.Column(db.String(64))
def __init__(self, **kwargs):
super(Patient, self).__init__(**kwargs)
@staticmethod
def _bootstrap(count=2000, locale='en'):
from mimesis.providers import Personal
person = Personal(locale)
for _ in range(count):
patient = Patient(
email=person.email(),
phone_number=person.telephone(),
full_name=person.full_name(gender='female'),
weight=person.weight(),
height=person.height(),
blood_type=person.blood_type()
)
db.session.add(patient)
try:
db.session.commit()
except Exception:
db.session.rollback()
```
Переходим в shell-mode:
```
(venv) ➜ python3 manage.py shell
```
И генерируем данные, предварительно убедившись в том, что база данных и подопытная модель доступны.
```
>>> db
>>> Patient
>>> Patient().\_bootstrap(count=4000, locale='ru') # Сгенерировать 4к записей на русском языке.
```
### Введение
Хотелось бы отметить, что мы будем приводить в примерах только базовые возможности библиотеки и, в основном, обойдемся несколькими наиболее часто встречающимися классами-провайдерами, ибо их слишком много, чтобы рассказывать обо всех в деталях. Если статья возбудит в вас интерес к библиотеке, то вы сможете найти [полезные ссылки](https://habrahabr.ru/post/318120/#poleznye-ssylki) в самом конце статьи и самостоятельно все изучить.
Библиотека устроена довольно просто и все, что вам необходимо для того, чтобы начать работать с данным — это создать экземпляр класса-провайдера. Наиболее часто встречающиеся данные в веб-приложениях — это личные данные пользователя, такие как `имя пользователя`, `имя`, `фамилия`, `возраст`, `кредитные данные` и т.п. Для генерации таких данных существует специальный класс-провайдер — `Personal()`, который принимает код языкового стандарта в виде строки, как показано ниже:
```
>>> from mimesis import Personal
# Создаем экземпляр класса-провайдера с данными для исландского языка.
>>> person = Personal('is')
# Выводим исландские мужские имена.
>>> for _ in range(0, 3):
... person.full_name(gender='male')
`Karl Brynjúlfsson`
`Rögnvald Eiðsson`
`Vésteinn Ríkharðsson`
```
Практически каждое веб-приложение требует ввода e-mail адреса при регистрации. Библиотека, разумеется поддерживает возможность генерировать e-mail адреса и делается это с помощью метода `email()` класса `Personal()`, как показано ниже:
```
# Женский:
>>> person.email(gender='female')
>>> 'lvana6108@gmail.com'
# Мужской:
>>> person.email(gender='male')
'john2454@yandex.com'
```
В способе, что был приведен выше кроется небольшая проблема, которая может несколько загрязнять код, если в приложении используется не один единственный класс-провайдер, а несколько. В таких случаях следует использовать объект `Generic()`, который дает доступ ко всем провайдерам из одного единственного объекта, как показано ниже:
```
>>> from mimesis import Generic
>>> # Согласно стандарту ISO 639-1, pl - это код Польши.
>>> g = Generic('pl')
>>> g.personal.full_name()
'Lonisława Podsiadło'
>>> g.datetime.birthday(readable=True)
'Listopad 11, 1997'
>>> g.personal.blood_type()
'A−'
```
Комбинирование данных дает большой простор. К примеру можно создать фиктивных держателей (женского пола) карты Visa (или MasterCard, Maestro):
```
>>> user = Personal('en')
>>> def get_card(sex='female'):
... owner = {
... 'owner': user.full_name(sex),
... 'exp_date': user.credit_card_expiration_date(maximum=21),
... 'number': user.credit_card_number(card_type='visa')
... }
... return owner
>>> for _ in range(0, 3):
... get_card()
```
Вывод:
```
{'exp_date': '02/20', 'owner': 'Laverna Morrison', 'card_number': '4920 3598 2121 3328'}
{'exp_date': '11/19', 'owner': 'Melany Martinez', 'card_number': '4980 9423 5464 1201'}
{'exp_date': '01/19', 'owner': 'Cleora Mcfarland', 'card_number': '4085 8037 5801 9703'}
```
Как уже говорилось выше, библиотека поддерживает более 20 классов-провайдеров, которые содержат данные на все случаи жизни (если нет, то ждем [PR](https://github.com/lk-geimfari/mimesis) с исправлением этого ужасного недоразумения). К примеру, если вы разрабатываете приложение ориентированное на грузоперевозки или на иную деятельность, связанную с транспортом и вам необходимо сгенерировать модели транспорта, то вы с легкостью сможете сделать это, воспользовавшись классом-провайдером `Transport()`, который содержит данные о транспорте:
```
>>> from mimesis import Transport
>>> trans = Transport()
>>> for _ in range(0, 5):
... trans.truck()
'Seddon-2537 IM'
'Karrier-7799 UN'
'Minerva-5567 YC'
'Hyundai-2808 XR'
'LIAZ-7174 RM'
```
Ну или можно указать маску модели транспорта:
```
>>> for _ in range(0, 5):
... trans.truck(model_mask="##@") # # - числа, @ - буквы
```
```
Henschel-16G
Bean-44D
Unic-82S
Ford-05Q
Kalmar-58C
```
Нередко при тестировании веб-приложений (тестирование блога — яркий пример) возникает необходимость сгенерировать текстовые данные (`текст`, `предложение`, `тег` и.т.п.). Вбивать вручную текст при тестировании — это долго и скучно и Mimesis позволяет этого избежать, благодаря классу-провайдеру `Text()`:
```
>>> from mimesis import Text
>>> text = Text('ru')
>>> text.text(quantity=3) # quantity - показатель количества предложений.
'Язык включает в себя средства порождения параллельных легковесных процессов и их взаимодействия через обмен асинхронными сообщениями в соответствии с моделью акторов. Python поддерживает несколько парадигм программирования, в том числе структурное, объектно-ориентированное, функциональное, императивное и аспектно-ориентированное. Например, определение функции, которое использует сопоставление с образцом, для выбора одного из вариантов вычисления или извлечения элемента данных из составной структуры, напоминает уравнение.'
```
Можно получить список случайных слов:
```
>>> text = Text('pt-br')
>>> text.words(quantity=5)
['poder', 'de', 'maior', 'só', 'cima']
```
Cгенерировать название улицы:
```
>>> from mimesis import Address
>>> address = Address('ru')
>>> address.address()
'ул. Хабаровская 651'
```
Получить название субъекта/штата/провинции странны, к которой относится выбранный языковой стандарт. В данном случае — это субъект Российской Федерации:
```
>>> address.state()
'Кировская область'
```
Сгенерировать координаты:
```
>>> address.coordinates()
{'latitude': -28.362892454682246, 'longitude': 11.512065821275826}
```
В библиотеке так же есть средства для романизации кириллических языков (на момент написания статьи поддерживаются только русский и украинский):
```
>>> from mimesis.decorators import romanized
>>> @romanized('ru')
... def name_ru():
... return 'Вероника Денисова'
...
>>> @romanized('uk')
>>> def name_uk():
... return 'Емілія Акуленко'
...
>>> name_ru()
'Veronika Denisova'
>>> name_uk()
'Emіlіja Akulenko'
```
На самом деле возможностей очень много и можно придумать огромное количество куда более наглядных примеров, в контексте которых данные будут выглядеть более ценными, чем выше. Мы ждем таких примеров от вас — читателей. Мы будем очень рады прочитать об успешном опыте применении библиотеки в ваших проектах.
### Полезные ссылки:
[Здесь](https://habrahabr.ru/post/319880/) вы можете найти вторую часть статьи.
[Здесь](https://medium.com/wemake-services) вы сможете прочитать дополненный вариант этой статьи и много других интересных статей на разные темы.
Github: [lk-geimfari/mimesis](https://github.com/lk-geimfari/mimesis/)
Read the Docs: [mimesis](https://mimesis.name/)
Спасибо за внимание и удачных вам тестов! | https://habr.com/ru/post/318120/ | null | ru | null |
# Что может пойти не так с Data Science? Сбор данных
[](https://habr.com/ru/company/ruvds/blog/510944/)
Сегодня существует 100500 курсов по Data Science и давно известно, что больше всего денег в Data Science можно заработать именно курсами по Data Science (зачем копать, когда можно продавать лопаты?). Основной минус этих курсов в том, что они не имеют ничего общего с реальной работой: никто не даст вам чистые, обработанные данные в нужном формате. И когда вы выходите с курсов и начинаете решать настоящую задачу — всплывает много нюансов.
Поэтому мы начинаем серию заметок «Что может пойти не так с Data Science», основанных на реальных событиях случившихся со мной, моими товарищами и коллегами. Будем разбирать на реальных примерах типичные задачи по Data Science: как это на самом деле происходит. Начнем сегодня с задачи сбора данных.
И первое обо что спотыкаются люди, начав работать с реальными данными — это собственно сбор этих самых релевантных нам данных. Ключевой посыл этой статьи:
> **Мы систематически недооцениваем время, ресурсы и усилия на сбор, очистку и подготовку данных.**
А главное, обсудим, что делать, чтобы этого не допустить.
По разным оценкам, очистка, трансформация, data processing, feature engineering и тд занимают 80-90% времени, а анализ 10-20%, в то время как практически весь учебный материал фокусируется исключительно на анализе.
Давайте разберем как типичный пример простую аналитическую задачу в трех вариантах и увидим, какими бывают «отягчающие обстоятельства».
И для примера опять же, мы рассмотрим подобные вариации задачи сбора данных и сравнения сообществ для:
1. Двух сабреддитов Reddit
2. Двух разделов Хабра
3. Двух групп Одноклассников
Условный подход в теории
------------------------
Открыть сайт и почитать примеры, если понятно, заложить несколько часов на чтение, несколько часов на код по примерам и отладку. Добавить несколько часов на сбор. Накинуть несколько часов про запас (умножить на два и прибавить N часов).
**Ключевой момент: временная оценка основана на предположениях и догадках о том, сколько это займет времени.**
Начать анализ времени необходимо с оценки следующих параметров для условной задачи, описанной выше:
* Какой размер данных и сколько его нужно физически собирать (\*см ниже\*).
* Какое время сбора одной записи и сколько нужно ждать, прежде чем можно собрать вторую.
* Заложить написание кода сохраняющего состояние и начинающего рестарт, когда (а не если) все упадет.
* Разобраться, нужна ли нам авторизация и заложить время получения доступа по API.
* Заложить количество ошибок, как функцию сложности данных — оценить по конкретной задаче: структура, сколько преобразований, что и как экстрактим.
* Заложить ошибки сети и проблемы с нестандартным поведением проекта.
* Оценить, если нужные функции в документации и если нет, то как и сколько нужно для a workaround.
Самое важное, что для оценки времени — вам фактически необходимо потратить время и усилия для «разведки боем» — только тогда ваше планирование будет адекватным. Поэтому как бы вас не пушили сказать «а сколько времени нужно для сбора данных» — выбейте себе времени на предварительный анализ и аргументируйте тем насколько время будет варьироваться в зависимости от реальных параметров задачи.
И сейчас мы продемонстрируем конкретные примеры, где такие параметры и будут меняться.
**Ключевой момент: оценка основана на анализе ключевых факторов, влияющих на объем и сложность работы.**
Оценка, основанная на догадках — это хороший подход, когда функциональные элементы достаточно небольшие и не так много факторов, которые могут существенно повлиять на структуру задачи. Но в случае ряда задач Data Science таких факторов становится крайне много и подобный подход становится неадекватным.
Сравнение сообществ Reddit
--------------------------
Начнем с самого простого случая (как потом окажется). Вообще, если совсем честно, перед нами практически идеальный случай, проверим наш чеклист сложности:
* Имеется аккуратный, понятный и документированный API.
* Крайне просто и главное автоматически получается токен.
* Есть [python wrapper](https://github.com/praw-dev/praw) — с кучей примеров.
* Сообщество которое занимается анализом и сбором данных на реддите (вплоть до youtube роликов объясняющих, как использовать python wrapper) [вот например](https://www.programcreek.com/python/example/86599/praw.Reddit).
* Нужные нам методы скорее всего существуют в API. Более того, код выглядит компактно и чисто, ниже пример функции собирающей комментарии к посту.
```
def get_comments(submission_id):
reddit = Reddit(check_for_updates=False, user_agent=AGENT)
submission = reddit.submission(id=submission_id)
more_comments = submission.comments.replace_more()
if more_comments:
skipped_comments = sum(x.count for x in more_comments)
logger.debug('Skipped %d MoreComments (%d comments)',
len(more_comments), skipped_comments)
return submission.comments.list()
```
*Взято из [этой](https://github.com/timendum/reddit-utilities/blob/master/thread-export.py) подборки удобных утилит для обертки.*
Несмотря на то что перед нами самый лучший случай здесь все же стоит учесть ряд важных факторов из реальной жизни:
* Лимиты API — мы вынуждены брать данные батчами (спать между запросами и тд).
* Время сбора — для полного анализа и сравнения придется заложить существенное время просто для паука пройтись по сабреддиту.
* Бот должен крутиться на сервере — вы не можете просто запустить его на ноуте, сложить в рюкзак и поехать по делам. Поэтому я запустил все на VPS. По промокоду habrahabr10 можно сэкономить еще 10% стоимости.
* Физическая недоступность некоторых данных (они видны админам или слишком сложно собираются) — это надо учесть, не все данные в принципе можно собрать за адекватное время.
* Ошибки работы сети: работа с сетью — это боль.
* Это живые настоящие данные — они чистыми не бывают.
Конечно, необходимо заложить в разработку указанные нюансы. Конкретные часы/дни зависят от опыта разработки или опыта работы над подобными задачами, тем не менее мы видим, что здесь задача исключительно инженерная и не требует дополнительных телодвижений для решения — можно все очень хорошо оценить, расписать и сделать.
Сравнение разделов Хабра
------------------------
Переходим к более интересному и нетривиальному случаю сравнению потоков и/или разделов Хабра.
Проверим наш чеклист сложности — здесь, чтобы понять каждый пункт уже придется немного потыкаться в саму задачу и поэкспериментировать.
* Сначала вы думаете, что есть API, но его нет. Да-да, у Хабра есть API, но только он недоступен для пользователей (а может и совсем не работает).
* Потом просто начинаете парсить html — «import requests», что может пойти не так?
* А как вообще парсить? Самый простой и часто используемый подход — итерировать по ID, отметим, что не самый эффективный и придется обрабатывать разные случаи — вот для примера плотность реальных ID среди всех существующих.
*Взято из [этой](https://habr.com/ru/post/218607/) статьи.*
* Сырые данные, завернутые в HTML поверх сети — это боль. Например, вы хотите собрать и сохранить рейтинг статьи: выдрали score из html и решили сохранить его как число для дальнейшей обработки:
1) int(score) кидает ошибку: так как на Хабре минус, как, например в строке "–5" — это короткое тире, а не знак минуса (неожиданно, да?), поэтому в какой-то момент пришлось поднимать парсер к жизни вот с таким ужасным фиксом.
```
try:
score_txt = post.find(class_="score").text.replace(u"–","-").replace(u"+","+")
score = int(score_txt)
if check_date(date):
post_score += score
```
Даты, плюсов и минусов может вообще не быть (как мы видим выше по функции check\_date и такое было).
2) Неэкранированные спецсимволы — они придут, нужно быть готовым.
3) Структура меняется в зависимости от типа поста.
4) Старые посты могут иметь \*\*странную структуру\*\*.
* По сути обработку ошибок и что может или не может произойти придется обрабатывать и нельзя предугадать наверняка, что пойдет не так и как еще может быть структура и что где отвалится — придется просто пробовать и учитывать ошибки, которые бросает парсер.
* Потом вы понимаете, что нужно парсить в несколько потоков иначе парс в один потом займет 30+ часов (это чисто время выполнения уже рабочего однопоточного парсера, который спит и не попадает ни под какие баны). В [этой](https://habr.com/ru/post/276383/) статье, это привело в какой-то момент к подобной схеме:
Итого чеклист по сложности:
* Работа с сетью и парсом html с итерацией и перебором по ID.
* Документы неоднородной структуры.
* Много мест, где код может легко упасть.
* Необходимо писать || код.
* Отсутствует нужная документация, примеры кода и/или сообщество.
Условная оценка времени для данной задачи будет в 3-5 раз выше, чем для сбора данных с Реддита.
Сравнение групп Одноклассников
------------------------------
Перейдем к самому технически интересному случаю из описанных. Для меня он был интересен именно тем, что на первый взгляд, он выглядит достаточно тривиальным, но совсем таким не оказывается — как только вы ткнете в него палочкой.
Начнет с нашего чеклиста сложности и отметим, что многие из них окажутся куда сложнее, чем выглядят вначале:
* API есть, но в нем почти полностью отсутствуют нужные функции.
* К определенным функциям нужно просить доступ по почте, то есть выдача доступа не мгновенная.
* Он ужасно документирован (начнем с того, что всюду мешаются русские и английские термины, причем абсолютно непоследовательно — иногда вам нужно просто угадать, что от вас где-то хотят) и, более того, не подходит по дизайну для получения данных, например, [нужной нам функции](https://apiok.ru/dev/methods/rest/discussions/discussions.getComments).
* Требует сессии в документации, а на деле ее не использует — и нет никакого способа разобраться во всех тонкостях режимов API, кроме как тыкаться и надеяться, что что-то будет работать.
* Отсутствуют примеры и сообщество, единственная точка опоры в сборе информации — небольшой [wrapper](https://github.com/alternativshik/python-odnoklassniki) на питоне (без большого количества примеров использования).
* Наиболее рабочим вариантов выглядит Selenium, так как многие нужные данные под замком.
1) То есть идет авторизация через фиктивного пользователя (и регистрация ручками).
2) Однако c Selenium никаких гарантий по корректной и повторяемой работе (по крайней в случае с ok.ru точно).
3) Сайт Ок.ру содержит ошибки JavaScript и иногда странно и непоследовательно себя ведет.
4) Нужно заниматься пагинацией, подгрузкой элементов и тд…
5) Ошибки API, которые отдает wrapper придется костыльно обрабатывать, например, вот так (кусочек экспериментального кода):
```
def get_comments(args, context, discussions):
pause = 1
if args.extract_comments:
all_comments = set()
#makes sense to keep track of already processed discussions
for discussion in tqdm(discussions):
try:
comments = get_comments_from_discussion_via_api(context, discussion)
except odnoklassniki.api.OdnoklassnikiError as e:
if "NOT_FOUND" in str(e):
comments = set()
else:
print(e)
bp()
pass
all_comments |= comments
time.sleep(pause)
return all_comments
```
Моя любимая ошибка была:
`OdnoklassnikiError("Error(code: 'None', description: 'HTTP error', method: 'discussions.getComments', params: …)”)`
6) В конечном итоге вариант Selenium + API выглядит наиболее рациональным вариантом.
* Необходимо сохранение состояния и рестарта системы, обработка множества ошибок, в том числе непоследовательного поведения сайта — причем эти ошибки, которые довольно сложно себе представить (если вы не профессионально пишите парсеры, разумеется).
Условная оценка времени для данной задачи будет в 3-5 раз выше, чем для сбора данных с Хабра. Несмотря на то что в случае с Хабром мы используем лобовой подход с парсом HTML, а в случае с ОК мы можем в критичных местах работать с API.
Выводы
------
Как бы с вас не требовали оценку сроков «на месте» (у нас же сегодня планирование!) объемного модуля пайплана обработки данных, время выполнения практически никогда невозможно оценить даже качественно без анализа параметров задачи.
Если говорить чуть более философски, то стратегии оценки в agile неплохо подходят для инженерных задач, но с задачами более экспериментальными и, в некотором смысле, «творческими» и исследовательскими, т.е., менее предсказуемыми, возникают трудности, как в примерах подобных тем, что мы разобрали здесь.
Конечно, сбор данных является просто ярким иллюстративным примером — обычно это задача кажется невероятно простой и технически несложной, и именно в деталях здесь чаще всего и таится дьявол. И именно на этой задаче получается показать весь спектр возможных вариантов того, что может пойти не так и насколько именно может затянуться работа.
Если пробежаться краем глаза по характеристикам задачи без дополнительных экспериментов, то Reddit и ОК выглядят похоже: есть API, python wrapper, но по сути, разница огромна. Если судить по этим параметрам, то парс Хабра выглядит сложнее, чем ОК — а на практике это совсем наоборот и именно это можно выяснить, проведя простые эксперименты по анализу параметров задачи.
По моему опыту наиболее эффективным подходом является примерная оценка времени, которая вам потребуется на сам предварительный анализ и простые первые эксперименты, чтение документации — они-то и позволят вам дать точную оценку для всей работы. В терминах популярной методологии agile — я прошу завести мне тикет под “оценку параметров задачи”, на основе которого я могу дать оценку того, что возможно выполнить в рамках “спринта” и дать более точную оценку по каждой задаче.
Поэтому наиболее эффективным, кажется аргумент, который бы показал «нетехническому» специалисту, как сильно будет варьироваться время и ресурсы в зависимости от параметров, которые еще предстоит оценить.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=param&utm_content=datascience1#order) | https://habr.com/ru/post/510944/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.