text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Эксперты обнаружили критическую уязвимость в sudo, баг в утилите был с 2011 года
Эксперты компании Qualys [обнаружили](https://blog.qualys.com/vulnerabilities-research/2021/01/26/cve-2021-3156-heap-based-buffer-overflow-in-sudo-baron-samedit) критическую уязвимость в утилите sudo. Злоумышленник может получить доступ с правами root, используя уязвимость [CVE-2021-3156](https://security-tracker.debian.org/tracker/CVE-2021-3156) под любым пользователем и без наличия записи в файле /etc/sudoers. Уязвимость можно применять для повышения привилегий в системе в непривилегированном процессе.
Специалисты Qualys проверили эксплойты с уязвимостью на дистрибутивах Ubuntu 20.04 (sudo 1.8.31), Debian 10 (sudo 1.8.27) и Fedora 33 (sudo 1.9.2). В этих дистрибутивах они получили полные привилегии в системе. Уязвимости подвержены и другие дистрибутивы Linux с утилитой sudo всех версий от 1.8.2 до 1.8.31p2 (legacy) и от 1.9.0 до 1.9.5p1 (stable). Уязвимость устранена разработчиками sudo в версии [1.9.5p2](https://www.sudo.ws/stable.html#1.9.5p2). Qualys прислала им всю необходимую информацию для устранения уязвимости 13 января этого года.
Эксперты Qualys пояснили, что уязвимость [попала](https://github.com/sudo-project/sudo/commit/8255ed69) в исходный код утилиты sudo в июле 2011 года. Ее использование возможно, если определенным образом вызвать переполнение буфера при обработке символов экранирования строки в параметрах, предназначенных для запуска команд в режиме shell при использовании sudoedit и указании аргументов "-i" или "-s". В этом случае экранирования параметров не происходит и появляется возможность работать далее с переполнением буфера и использовать ошибки в обработчике утилиты. Специалисты Qualys с помощью трех эксплойтов смогли активировать уязвимость и получить права root в системе, манипулируя значениями аргументов и при вызове sudoedit.
*Пример использования уязвимости. Qualys не опубликовала исходный код эксплойтов для ее активации.*
Для проверки наличия уязвимости в системе нужно под обычным пользователем запустить команду `sudoedit -s /`. Если в ответ будет выдана ошибка с текстом в начале «sudoedit:», то уязвимость есть. Исправленные версии sudo выдают в этом случае текст с ошибкой, начинающейся с «usage:». | https://habr.com/ru/post/539526/ | null | ru | null |
# Кунг-фу стиля Linux: делиться — это плохо
В детском саду вы узнали о том, что делиться — это хорошо. Но, если речь заходит о компьютерной безопасности, часто оказывается, что не всё так однозначно. Концепция пространств имён (namespaces) появилась в ядре Linux начиная с версии 2.6.24. Это случилось много лет назад, но использование пространств имён не стало массовым явлением, несмотря на то, что существуют инструменты для работы с ними. Разумеется, задумываться о пространствах имён нужно далеко не всегда. Но это одна из тех вещей, которые, если в них возникает необходимость, дают нам просто бесценные возможности. Если описать эти возможности в двух словах, то получится, что пространства имён позволяют предоставить процессу его собственные, приватные ресурсы, и, что важнее, запретить процессу доступ к ресурсам из других пространств имён.
[](https://habr.com/ru/company/ruvds/blog/599109/)
На самом деле мы, работая в Linux, постоянно пользуемся этой концепцией. Каждый запускаемый нами процесс существует в среде, описываемой неким набором пространств имён. Почему я говорю тут о «наборе» пространств имён? Дело в том, что существуют пространства имён, используемые для управления различными ресурсами. Например, можно настроить особое сетевое пространство имён, которое позволит предоставить процессу его собственный набор сетевых ресурсов — таких, например, как таблицы маршрутизации и правила файрвола.
Поговорим о том, как в Linux организована работа с пространствами имён, и о том, что они скрывают.
**Все переводы серии**
[Кунг-фу стиля Linux: удобная работа с файлами по SSH](https://habr.com/ru/company/ruvds/blog/520752/)
[Кунг-фу стиля Linux: мониторинг дисковой подсистемы](https://habr.com/ru/company/ruvds/blog/527238/)
[Кунг-фу стиля Linux: глобальный поиск и замена строк с помощью ripgrep](https://habr.com/ru/company/ruvds/blog/527242/)
[Кунг-фу стиля Linux: упрощение работы с awk](https://habr.com/ru/company/ruvds/blog/527244/)
[Кунг-фу стиля Linux: наблюдение за файловой системой](https://habr.com/ru/company/ruvds/blog/528422/)
[Кунг-фу стиля Linux: наблюдение за файлами](https://habr.com/ru/company/ruvds/blog/528430/)
[Кунг-фу стиля Linux: удобный доступ к справке при работе с bash](https://habr.com/ru/company/ruvds/blog/528432/)
[Кунг-фу стиля Linux: великая сила make](https://habr.com/ru/company/ruvds/blog/528434/)
[Кунг-фу стиля Linux: устранение неполадок в работе incron](https://habr.com/ru/company/ruvds/blog/529828/)
[Кунг-фу стиля Linux: расшаривание терминала в браузере](https://habr.com/ru/company/ruvds/blog/529836/)
[Кунг-фу стиля Linux: синхронизация настроек](https://habr.com/ru/company/ruvds/blog/531088/)
[Кунг-фу стиля Linux: бесплатный VPN по SSH](https://habr.com/ru/company/ruvds/blog/530944/)
[Кунг-фу стиля Linux: превращение веб-приложений в полноценные программы](https://habr.com/ru/company/ruvds/blog/529838/)
[Кунг-фу стиля Linux: утилита marker и меню для командной строки](https://habr.com/ru/company/ruvds/blog/529840/)
[Кунг-фу стиля Linux: sudo и поворот двух ключей](https://habr.com/ru/company/ruvds/blog/532334/)
[Кунг-фу стиля Linux: программное управление окнами](https://habr.com/ru/company/ruvds/blog/532342/)
[Кунг-фу стиля Linux: организация работы программ после выхода из системы](https://habr.com/ru/company/ruvds/blog/533336/)
[Кунг-фу стиля Linux: регулярные выражения](https://habr.com/ru/company/ruvds/blog/533334/)
[Кунг-фу стиля Linux: запуск команд](https://habr.com/ru/company/ruvds/blog/536958/)
[Кунг-фу стиля Linux: разбираемся с последовательными портами](https://habr.com/ru/company/ruvds/blog/544512/)
[Кунг-фу стиля Linux: базы данных — это файловые системы нового уровня](https://habr.com/ru/company/ruvds/blog/568302/)
[Кунг-фу стиля Linux: о повторении кое-каких событий сетевой истории](https://habr.com/ru/company/ruvds/blog/568308/)
[Кунг-фу стиля Linux: PDF для пингвинов](https://habr.com/ru/company/ruvds/blog/573876/)
[Кунг-фу стиля Linux: делаем всё и сразу](https://habr.com/ru/company/ruvds/blog/567158/)
[Кунг-фу стиля Linux: файловые системы пользовательского пространства теперь доступны и в Windows](https://habr.com/ru/company/ruvds/blog/578292/)
[Кунг-фу стиля Linux: делиться — это плохо](https://habr.com/ru/company/ruvds/blog/599109/)
Существуют следующие пространства имён:
* Пространство имён файловой системы (mount). Сюда относятся ресурсы файловых систем, в частности, описание точек монтирования. Этими описаниями, доступными одному пространству имён файловой системы, можно поделиться с другими пространствами имён. Для того чтобы это сделать, пользователь должен явным образом выразить своё намерение.
* Пространство имён UTS. Оно отвечает за управление такими вещами, как имя хоста и доменное имя.
* Пространство имён IPC. Программа, с которой связано собственное пространство имён IPC, будет обладать собственной разделяемой памятью, собственными очередями сообщений, семафорами и другими объектами, отвечающими за межпроцессное взаимодействие.
* Пространство имён для сетей (network). Процессы, находящиеся в сетевом пространстве имён, будут обладать собственными сетевыми ресурсами, такими, как стеки сетевых протоколов и настройки системных сущностей, имеющих отношение к сетям.
* Пространство имён PID. Процессы, входящие в состав пространства имён PID, не видят других процессов, находящихся за пределами этого пространства.
* Пространство имён cgroup. Это — пространство имён, которое даёт виртуализированное представление механизмов, используемых для управления процессором.
* Пространства имён пользователей (user). Эти пространства имён позволяют изолировать отдельных пользователей, группы пользователей и другие подобные ресурсы.
Ясно то, что некоторые из этих пространств имён отличаются более широкой сферой использования, чем другие. Например, если имеется система программ, работающих совместно, может показаться привлекательным, создание закрытого пространства, предназначенного специально для них. Там, например, можно наладить межпроцессное взаимодействие этих программ, можно организовать сетевой обмен данными между ними.
Эксперименты в командной оболочке
---------------------------------
Если вы хотите поэкспериментировать с пространствами имён с использованием командной оболочки — можете воспользоваться командой `unshare`. Её имя может показаться странным, но стоит обратить внимание на то, что она названа именно так из-за того, что новый процесс обычно получает доступ к пространствам имён, которыми делится с ним его родительский процесс. Команда `unshare` позволяет создавать новые пространства имён.
Одной из ключевых возможностей этой команды (или её странностью) является тот факт, что она по умолчанию запускает программу и при этом создаёт новые пространства имён. Но эту программу она с этими пространствами имён не связывает. Они назначаются дочерним процессам, создаваемым этой программой. При вызове `unshare` можно воспользоваться опцией `--fork`. Это приведёт к тому, что то, как она сработает, будет ближе к тому, чего от неё можно было бы ожидать.
Например — откроем новый экземпляр командной оболочки в её собственном частном пространстве:
```
sudo unshare --pid --fork --mount-proc /bin/bash
ps alx
```
Если попробовать эту команду, не создавая при этом отдельного пространства имён, и поинтересоваться списком процессов, этот список будет очень длинным. А такой же список, выведенный внутри нового пространства имён, выглядит не таким уж и большим.
```
F UID PID PPID PRI NI VSZ RSS WCHAN STAT TTY TIME COMMAND
4 0 1 0 20 0 10820 4376 - S pts/6 0:00 /bin/bash
0 0 9 1 20 0 12048 1168 - R+ pts/6 0:00 ps alx
```
Тут стоит немного поразмыслить о том, как работают разные утилиты. Например, `ps` читает данные из `/proc`. Поэтому без `--mount-proc`, она, как обычно, выведет список всех основных процессов (попробуйте это сделать). С ними нельзя будет взаимодействовать, но, так как у нас есть возможность чтения данных из `/proc`, нам виден их список. Флаг `--mount-proc` — это сокращённый вариант описания последовательности действий, когда сначала используют `--mount` (для получения нового пространства имён файловой системы), а затем монтируют файловую систему `proc`.
Если опустить опцию `fork` — оболочка будет вести себя непривычно, так как она обычно запускает новые процессы, а они теперь окажутся в пространстве имён, отличающемся от того, где находится главный процесс.
Если добавить к большей части аргументов (например — это `--pid` или `--mount`) имя файла — можно создавать постоянные пространства имён, которые можно расшаривать между различными процессами. Ещё можно использовать виртуальные Ethernet-адаптеры (виртуальные устройства `veth`) или сетевой мост для того, чтобы давать доступ к сетям из одного пространства имён другим пространствам имён.
Пространства имён файловой системы и другие опции
-------------------------------------------------
Ещё один интересный механизм изоляции, на который стоит взглянуть поближе, заключается в работе с таблицей монтирования файловых систем. Их совместное использование в различных пространствах имён можно организовать несколькими способами. Если нужна полная приватность — этого можно достичь, но можно, кроме того, организовать общий доступ к таблице монтирования в пределах группы, или отслеживать изменения в других группах, но не давать доступа к собственным изменениям. Подробности об этом можно узнать в [справке](https://man7.org/linux/man-pages/man7/mount_namespaces.7.html).
Тут можно отметить одну деталь. Заключается она в том, что, так как пространства имён изолированы, обычный пользователь может иметь квази-права суперпользователя в новых пространствах имён. Сделать это позволяет опция `--map-root-user`. Она, кроме того, включает опцию, запрещающую пользователям вызов `setgroups`. Это могло бы позволить им получить повышенные разрешения.
Тут, конечно, ещё много всего. Если у вас установлен пакет `util-linux` — обратитесь за подробностями к man-странице `unshare`. Если вы хотите воспользоваться этими возможностями в некоей программе, что, пожалуй, легче себе представить, чем их непосредственное использование, можете обратиться к системному вызову `unshare`. Подробности об этом можно найти в `man 2 unshare`. Обратите внимание на то, что при использовании системных вызовов, в вашем распоряжении окажется даже больше власти, чем при применении обычных команд. Например, можно отсоединить файловую систему. Это близко связано с системным вызовом `clone`, который представляет собой нечто вроде супер-версии `fork`.
Может, вам покажется интересным то, что все данные пространства имён для процесса выводятся в `/proc`. Например — попробуйте такую команду:
```
sudo ls -l /proc/$$/ns/*
```
Вы увидите специализированные символические ссылки с информацией о разных пространствах имён для текущего процесса. Например:
```
lrwxrwxrwx 1 alw alw 0 Dec 8 07:29 /proc/2182630/ns/cgroup -> 'cgroup:[4026531835]'
lrwxrwxrwx 1 alw alw 0 Dec 8 07:29 /proc/2182630/ns/ipc -> 'ipc:[4026531839]'
lrwxrwxrwx 1 alw alw 0 Dec 8 07:29 /proc/2182630/ns/mnt -> 'mnt:[4026531840]'
lrwxrwxrwx 1 alw alw 0 Dec 8 07:29 /proc/2182630/ns/net -> 'net:[4026531992]'
lrwxrwxrwx 1 alw alw 0 Dec 8 07:29 /proc/2182630/ns/pid -> 'pid:[4026531836]'
lrwxrwxrwx 1 alw alw 0 Dec 8 07:29 /proc/2182630/ns/pid_for_children -> 'pid:[4026531836]'
lrwxrwxrwx 1 alw alw 0 Dec 8 07:29 /proc/2182630/ns/time -> 'time:[4026531834]'
lrwxrwxrwx 1 alw alw 0 Dec 8 07:29 /proc/2182630/ns/time_for_children -> 'time:[4026531834]'
lrwxrwxrwx 1 alw alw 0 Dec 8 07:29 /proc/2182630/ns/user -> 'user:[4026531837]'
lrwxrwxrwx 1 alw alw 0 Dec 8 07:29 /proc/2182630/ns/uts -> 'uts:[4026531838]'
```
Это — один из «линуксизмов», которые иногда выглядят таинственно, но могут оказаться чрезвычайно полезными тогда, когда они кому-то понадобятся. Даже если прямо сейчас вам всё это и не нужно, в этом стоит разобраться. Это, например, может помочь вам решить какую-нибудь вставшую перед вами программистскую проблему. Конечно, вы можете запустить свою программу в её собственной виртуальной машине. Но это будет образец тяжеловесного решения, так как ту же задачу можно решить, проще, пользуясь аккуратными инструментами, позволяющими изолировать от внешнего мира то, что нужно. И сделать это можно не только вручную, но и из shell-скрипта.
Пользуетесь ли вы пространствами имён Linux?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=kungfu_stilya_linux_delitsya_eto_ploxo) | https://habr.com/ru/post/599109/ | null | ru | null |
# Пример использования Google AdWords API
Многие рекламодатели знают о преимуществах использования API в контекстной рекламе. Допустим, вам нужно запустить рекламную кампанию с большим количеством однотипных объявлений, но для разных товаров. В этом случае и приходит на помощь API-интерфейс. Вы легко и быстро переносите данные из базы MySQL в рекламную кампанию. И все! Дело сделано. Можно немного подредактировать и запускать. Именно такой схемой мы неоднократно пользовались для рекламы нашего книжного магазина в Яндекс.Директе.
А вот с Google Adwords все оказалось далеко не так просто. Мы долго пытались использовать эту схему в Adwords, переворошили кучу информации в Интернете, пока не узнали следующее от службы поддержки Google:
`На данный момент AdWords API не доступен для рекламодателей РФ. Приносим извинения за неудобства.`
Очень-очень жаль. Но мы не теряем надежды, что рано или поздно Google откроет возможность использовать API-интерфейс и у нас в России. Именно для такого случая мы решили рассказать подробно о нашем примере использования API в Adwords. Наш пример на ура работал на тестовом сервере Google, но не заработал на рабочем сервере по вышеуказанным причинам.
Схема эта довольно нетривиальна, поэтому в будущем (когда API для Adwods в России будет открыт) многим облегчит жизнь.
#### Шаг 1. Создание PHP кода
Сначала создаем PHP код для переноса данных из базы MySQL сайта в AdWords. Последнюю версию PHP библиотеки можно скачать [с этой страницы](http://code.google.com/p/google-api-adwords-php/). Так же, по этой ссылке можно найти много полезной информации, которая необходима в процессе написания кода.
Наш пример использования Google AdWords API для переноса данных из базы MySQL сайта в AdWords можно скачать [здесь](http://rekomenda.ru/files/AdWordsAPI.tar.bz2) в виде архива. Примечание: при скачивании этого архива в Windows антивирус NOD может на долго задуматься.
Данный архив содержит следующие файлы:
* aw\_api\_php\_lib\_2.2.0 — библиотека PHP от Google
* example.php — исполняемый файл содержащий пример кода
* logfile\_2011\_01\_26\_13\_58\_09.txt — пример лога в результате работы example.php
Стоит обратить внимание, что на данный момент последняя версия библиотеки — 2.4.1
В примере используется более старая версия — 2.2.0
Код в example.php имеет комментарии, которые должны помочь при разработке своей версии экспортера. Далее описаны основные шаги, которые выполняются в примере.
##### 1.1 Инициализация начальных параметров
Блок кода содержит инициализацию параметров и создание необходимых объектов из библиотеки aw\_api\_php\_lib\_2.2.0. Во время работы программы библиотека пишет свои логи в директорию ./aw\_api\_php\_lib\_2.2.0/src/Logs Помимо этого скрипт example.php записывает процесс работы в свой собственный лог файл.
##### 1.2 Получение данных из SQL и заполнение $booksArray
На наш взгляд данный блок кода является самым сложным участком работы. В нем необходимо реализовать алгоритм, который будет превращать информацию о товаре в объявление в AdWords. Сложность заключается в том, чтобы применяя один и тот же алгоритм, формировать эффективные объявления для всех товаров.
В примере используется следующий алгоритм экспорта данных:
1. Из SQL берется информация о книге: автор, название, url.
2. Из информации об авторе формируется заголовок для объявления.
3. Из информации о названии книги формируются два текстовых поля для тела объявления.
4. Из информации об авторе и названии книги формируются ключевые фразы для объявления.
5. Сформированная информация сохраняется в массив $booksArray для дальнейшей отправки на сервер.
При формировании объявления мы не забываем о правилах Adwords:
* Длинна заголовка объявления должна быть меньше 25 символов. [Подробнее](http://adwords.google.com/support/aw/bin/answer.py?hl=ru&answer=6095).
* Длинна одного блока в теле объявления должна быть меньше 35 символов. Блоков должно быть два.
* Слов в фразе для объявления должно быть меньше 10.
* Некоторые символы использовать в объявлении нельзя. [Подробнее](http://adwords.google.com/support/aw/bin/answer.py?hl=ru&answer=53539).
##### 1.3 Остальные блоки кода
Остальные блоки кода в примере на основе сформированных данных в $booksArray создают объекты библиотеки aw\_api\_php\_lib\_2.2.0 и отправляют их на сервер Google.
Порядок создания и отправки информации следующий:
1. При необходимости создаем кампанию или используем уже существующую.
2. Создаем группы, которые будут содержать объявления.
3. В группы добавляем объявления.
4. В группы добавляем ключевые фразы для объявлений.
#### Шаг 2. Тестирование кода
Для тестирования Google предоставляет специальный тестовый сервер, на котором можно проверить работу скриптов. Чтобы использовать тестовый сервер, делаем следующее:
1. [Создаем](https://www.google.com/accounts/NewAccount) Google акаунт с определенным email.
2. Определяем, какой сервер использовать (тестовый или рабочий), в файле ./aw\_api\_php\_lib\_2.2.0/src/Google/Api/Ads/AdWords/settings.ini
Для работы с тестовым сервером необходимо поставить
`DEFAULT_SERVER = "https://adwords-sandbox.google.com"`
Для работы с рабочим сервером необходимо поставить
`DEFAULT_SERVER = "https://adwords.google.com"`
Стоит обратить внимание на параметр `DEFAULT_VERSION = "v200909"`. Он определяет версию библиотеки, которая будет использоваться.
3. Данные для аутентификации библиотека берет из файла ./aw\_api\_php\_lib\_2.2.0/src/Google/Api/Ads/AdWords/auth.ini
Пример содержания файла для тестового сервера:
`email = "adwords@rekomenda.ru"`
Пример содержания файла для рабочего сервера:
`email = "adwords@rekomenda.ru"`
4. [Создаем](http://code.google.com/apis/adwords/docs/sandbox.html) аккаунт My Client Center (MCC) в тестовом сервере. Для этого необходимо вызвать метод GetCampaignService(). Этот метод есть в примере, поэтому можно отдельно его не вызывать.
#### Шаг 3. Создание My Client Center
У нас уже есть обычный аккаунт AdWords. Но как оказалось, обычного аккаунта AdWords для использования API недостаточно. Для использования AdWords API необходимо создать [My Client Center (MCC)](http://adwords.google.com/support/aw/bin/answer.py?hl=en&answer=7725) и привязать его к обычному акаунту AdWords.
1. Создаем MCC на этой [странице](http://www.google.com/intl/en/adwords/myclientcenter/).
2. [Связываем](http://adwords.google.com/support/aw/bin/answer.py?hl=en&answer=7732) обычный аккаунт AdWords c MCC.
3. В MCC настраиваем и активируем [AdWords API Center](https://adwords.google.com/support/aw/adwordsapi/bin/answer.py?hl=ru&answer=15104). Стоит обратить внимание, что при активации можно указать, что вы используете API для своего личного бизнеса. В этом случае, возможно, вам будут предоставлены бесплатные API юниты. Подробнее о стоимости юнитов [здесь](http://adwords.google.com/support/aw/bin/answer.py?hl=en&answer=152597).
После активации MCC AdWords API Center будет выглядеть приблизительно так:
Полученный Developer token необходимо указать в auth.ini файле.
Изменяем параметры файлов settings.ini и auth.ini для использования рабочего сервера (как было указано выше) и в теории можно приступать к экспорту данных в рабочий AdWords.
#### Шаг 4. Ожидание у моря погоды
При попытке экспортировать данные не в тестовый сервер, а в рабочий возникает ошибка: INCOMPLETE\_SIGNUP\_LATEST\_NETAPI\_TNC\_NOT\_AGREED
Эта ошибка как раз и означает то, что Google Adwords API не поддерживается в России.
Будем надеяться, что возможность использовать AdWords API все таки в России появится.
В дальнейших постах планируем описать более удачный пример экспорта данных с использованием Яндекс.Директ API.
**UPD** В комментариях к этому топику мне подсказали, что на самом деле AdWords API в РФ доступен и активно используется многими компаниями. А служба поддержки ввела меня в заблуждение.
Однако оплатить использование АПИ банковской картой пока нельзя. Чтобы получить доступ, необходимо обратиться в тех поддержку и организовать кредитную линию. Для этого придется подписать соглашение (Terms and Conditions) на бумаге, на русском. Соглашение можно отправить по почте. Тех. поддержка включает после этого доступ вручную.
Строго списка требований для открытия кредитной линии нет, часть требований можно посмотреть [здесь](http://adwords.google.com/support/aw/bin/topic.py?hl=ru&topic=15960). Решение принимается в индивидуальном порядке, по заявке.
**UPD 2** Этот топик был по ошибке удален, но поскольку информация была полезна для некоторых пользователей, и к тому же в статье появилась новая актуальная информация, я решила опубликовать топик еще раз. | https://habr.com/ru/post/112603/ | null | ru | null |
# On recursive queries
This article deals with writing recursive queries. This topic was brought up routinely, but the discussion was usually limited to simple cases related to trees: to descend from a vertex to the leaves and to ascend from a vertex to the root. We will address a more complicated case of an arbitrary graph.
Let's start with recalling the theory (very briefly since all of it is trivial), and then we will discuss what to do if it is unclear how to approach a real-life problem or if it seems to be clear, but the query persistently fails to work fine.
For an exercise, we will use the [airlines demo database](https://postgrespro.com/docs/postgrespro/12/demodb-bookings) and try to write a query to find the shortest route from one airport to another.
A little theory
---------------
The good old relational SQL adequately does the job with unordered sets: there is a whole panoply of capabilities for them both in the language and «under the hood» of the DBMS. What SQL dislikes is when one jerks it in a loop row by row rather than have the task performed in one statement. The optimizer gives up and withdraws, leaving you alone face to face with the performance.
A recursive query is just a technique to implement a loop right in SQL. It's not that it is pretty often necessary, but it sometimes happens to be. And here complications arise since a recursive query is not very similar to a usual query and even less to a usual loop.
A general format of a recursive query is as follows:
`**WITH RECURSIVE t AS (
non-recursive term (1)
UNION ALL
recursive term (2)
)
SELECT \* FROM t; (3)**`
The non-recursive term (1) is performed first. Then the recursive term (2) is iterated while it returns some rows. The recursive term is called so because it can access the output of the previous iteration that is available under the name of `t`.
In the process, the output of each iteration is placed into a resulting table, which will be available under the same name of `t` when all the query is complete (3). If we replace UNION ALL with UNION, duplicate rows will be eliminated at each iteration.
Using pseudocode, we may represent this as follows:
`**res ← EMPTY;
t ← (non-recursive term);
WHILE t IS NOT EMPTY LOOP
res ← res UNION ALL t;
aux ← (recursive term);
t ← aux;
END LOOP;
t ← res;**`
Here is a simple example:
`**demo=# WITH RECURSIVE t(n,factorial) AS (
VALUES (0,1)
UNION ALL
SELECT t.n+1, t.factorial\*(t.n+1) FROM t WHERE t.n < 5
)
SELECT \* FROM t;**
n | factorial
---+-----------
0 | 1
1 | 1
2 | 2
3 | 6
4 | 24
5 | 120
(6 rows)`
And this is enough to recall the basics. If something is unclear as early as at this point, it's time [to read the documentation](https://postgrespro.com/docs/postgresql/current/queries-with).
Practice
--------
Armed with the theory we can now (in theory) write the above query: search of the shortest route from, say, Ust-Kut (UKX) to Nerungri (CNN).
From the entire demo database, we will need two tables: `airports` and `routes`. Formally, `routes` is a view, but we do not need to think about it. (If you are unaware of the structure of the demo database yet, review [its description](https://postgrespro.com/docs/postgrespro/12/demodb-bookings).)
The query may look somewhat like this:
`**WITH RECURSIVE p(last\_arrival, destination, hops, flights, found) AS (
SELECT a\_from.airport\_code,
a\_to.airport\_code,
ARRAY[a\_from.airport\_code],
ARRAY[]::char(6)[],
a\_from.airport\_code = a\_to.airport\_code
FROM airports a\_from, airports a\_to
WHERE a\_from.airport\_code = 'UKX'
AND a\_to.airport\_code = 'CNN'
UNION ALL
SELECT r.arrival\_airport,
p.destination,
(p.hops || r.arrival\_airport)::char(3)[],
(p.flights || r.flight\_no)::char(6)[],
bool\_or(r.arrival\_airport = p.destination) OVER ()
FROM routes r, p
WHERE r.departure\_airport = p.last\_arrival
AND NOT r.arrival\_airport = ANY(p.hops)
AND NOT p.found
)
SELECT hops,
flights
FROM p
WHERE p.last\_arrival = p.destination;**`
This is, certainly, great, but how can we arrive at it, when there is nothing on the screen but a blinking cursor?
> «At this point in the videotape he always wonders if he's inadvertently set his beer down on the fast-forward button, or something, because the dancers go straight from their vicious Randy parody into something that obviously qualifies as advanced dancing. Randy knows that the steps they are doing are nominally the same as the basic steps demonstrated earlier, but he's damned if he can tell which is which, once they go into their creative mode. There is no recognizable transition, and that is what pisses Randy off, and has always pissed him off, about dancing lessons. Any moron can learn to trudge through the basic steps. That takes all of half an hour. But when that half-hour is over, dancing instructors always expect you'll take flight and go through one of those miraculous time lapse transitions that happen only in Broadway musicals and begin dancing brilliantly. Randy supposes that people who are lousy at math feel the same way: the instructor writes a few simple equations on the board, and ten minutes later he's deriving the speed of light in a vacuum.»
>
>
>
> *— Neal Stephenson. «Cryptonomicon»*
>
>
For instance, I cannot make up such a query off the cuff. Therefore, let's move gradually.
So, we need to find a route. A route from point A to B is a sequence of flights. The first flight leaves from A to somewhere, from this somewhere to somewhere else and so on, until the last flight ends in the sought point B.
How can we represent such a chain? From the relational standpoint, it is logical to make it a table with the *ordinal number* and *airport* columns. But we need to work with the chain as a single object, so the most reasonable option is to represent it as an array: [*airport*, *airport*, ...]. (If this is complicated for you, read about [arrays](https://postgrespro.com/docs/postgresql/current/arrays.html) and [functions](https://postgrespro.com/docs/postgresql/current/functions-array.html) to manipulate them.)
It is clear what to start the iteration with: with the airport at Ust-Kut.
`**demo=# SELECT ARRAY[airport\_code] FROM airports WHERE airport\_code = 'UKX';**
array
-------
{UKX}
(1 row)`
Why not just ARRAY['UKX']? It makes sense to secure ourselves a little: if we make a typo in the airport code, the query will return nothing.
Now imagine that the result of this initial iteration is stored in a table and we need to do the second iteration. And we can really do so: create and fill the table and write queries with it. But it is easier to make use of WITH:
`**demo=# WITH p(last\_arrival, hops) AS (
SELECT airport\_code,
ARRAY[airport\_code]
FROM airports
WHERE airport\_code = 'UKX'
)
SELECT \* FROM p;**
last_arrival | hops
--------------+-------
UKX | {UKX}
(1 row)`
We called the column *hops* to avoid confusion. Besides, we added one more (*last\_arrival*) for the last point in our future chain. We could compute the last element of the array (p.hops[cardinality(p.hops)]) instead, but this is not so demonstrable.
Now there is the second iteration:
`**demo=# WITH p(last\_arrival, hops) AS (
SELECT airport\_code,
ARRAY[airport\_code]
FROM airports
WHERE airport\_code = 'UKX'
)
SELECT r.arrival\_airport AS last\_arrival,
p.hops || ARRAY[r.arrival\_airport] AS hops
FROM routes r, p
WHERE r.departure\_airport = p.last\_arrival;**
last_arrival | hops
--------------+-----------
KJA | {UKX,KJA}
(1 row)`
What did we do? We got the first iteration (the «p» table) and joined it with routes. We specified a departure airport as the last airport in the chain, and we appended the arrival airport to the chain. It appears that from Ust-Kut only flights to Krasnoyarsk are available.
Now it is more or less clear how to put this together into a recursive query. We add the magic word RECURSIVE and combine the query with the first iteration using UNION ALL. And in the main query, we select the chain that eventually led to the destination airport (CNN).
Is it something like this?
`**demo=# WITH RECURSIVE p(last\_arrival, hops) AS (
SELECT airport\_code,
ARRAY[airport\_code]
FROM airports
WHERE airport\_code = 'UKX'
UNION ALL
SELECT r.arrival\_airport,
p.hops || r.arrival\_airport
FROM routes r, p
WHERE r.departure\_airport = p.last\_arrival
)
SELECT \*
FROM p
WHERE p.last\_arrival = (
SELECT airport\_code FROM airports WHERE airport\_code = 'CNN'
);**
ERROR: recursive query "p" column 2 has type character(3)[] in non-recursive term but type bpchar[] overall
LINE 3: ARRAY[airport_code]
^
HINT: Cast the output of the non-recursive term to the correct type.`
Hmm. Postgres complains that the second column has the `character(3)[]` type in the non-recursive term, while the resulting type is `bpchar[]`. The `bpchar` (blank-padded char) type is the internal name of the `char` type. Unfortunately, the concatenation of arrays does not retain element types, and therefore, it is required to explicitly cast the types.
`**demo=# WITH RECURSIVE p(last\_arrival, hops) AS (
SELECT airport\_code,
ARRAY[airport\_code]
FROM airports
WHERE airport\_code = 'UKX'
UNION ALL
SELECT r.arrival\_airport,
(p.hops || r.arrival\_airport)::char(3)[]
FROM routes r, p
WHERE r.departure\_airport = p.last\_arrival
)
SELECT \*
FROM p
WHERE p.last\_arrival = (
SELECT airport\_code FROM airports WHERE airport\_code = 'CNN'
);**`
There is no error anymore, but alas — the query has hung. So what shall we do now?
Let's investigate. Let's try to run the query step by step and see what happens at each iteration.
It's clear that we can repeat the trick of pushing the first iteration into the table and gradually combining the query with new iterations, but this is unduly annoying, and error-prone. But there is a better way.
Let's augment our query with one more column for the number of the iteration (the column to be called `level`). It will equal one for the first iteration, and then we will increase it. It won't help in itself, but we can now stop execution of the query wherever we like. We've seen the first two iterations, let's look at the third one now:
`**demo=# WITH RECURSIVE p(last\_arrival, hops, level) AS (
SELECT airport\_code,
ARRAY[airport\_code],
1
FROM airports
WHERE airport\_code = 'UKX'
UNION ALL
SELECT r.arrival\_airport,
(p.hops || r.arrival\_airport)::char(3)[],
p.level + 1
FROM routes r, p
WHERE r.departure\_airport = p.last\_arrival
AND p.level < 3
)
SELECT \* FROM p;**
last_arrival | hops | level
--------------+---------------+-------
UKX | {UKX} | 1
KJA | {UKX,KJA} | 2
UKX | {UKX,KJA,UKX} | 3
OVB | {UKX,KJA,OVB} | 3
OVB | {UKX,KJA,OVB} | 3
NOZ | {UKX,KJA,NOZ} | 3
NOZ | {UKX,KJA,NOZ} | 3
AER | {UKX,KJA,AER} | 3
SVO | {UKX,KJA,SVO} | 3
NUX | {UKX,KJA,NUX} | 3
UIK | {UKX,KJA,UIK} | 3
UIK | {UKX,KJA,UIK} | 3
BAX | {UKX,KJA,BAX} | 3
KRO | {UKX,KJA,KRO} | 3
OVS | {UKX,KJA,OVS} | 3
(15 rows)`
And we face something unexpected.
First, some rows are duplicated (for example: {UKX,KJA,OVB}). This is actually correct since there are two different flights from Krasnoyarsk (KJA) to Novosibirsk (OVB):
`**demo=# SELECT flight\_no
FROM routes
WHERE departure\_airport = 'KJA'
AND arrival\_airport = 'OVB';**
flight_no
-----------
PG0206
PG0207
(2 rows)`
Let's add the flight number to the query in order to distinguish the rows; we will need it anyway.
`**demo=# WITH RECURSIVE p(last\_arrival, hops, flights, level) AS (
SELECT airport\_code,
ARRAY[airport\_code],
ARRAY[]::char(6)[],
1
FROM airports
WHERE airport\_code = 'UKX'
UNION ALL
SELECT r.arrival\_airport,
(p.hops || r.arrival\_airport)::char(3)[],
(p.flights || r.flight\_no)::char(6)[],
p.level + 1
FROM routes r, p
WHERE r.departure\_airport = p.last\_arrival
AND p.level < 3
)
SELECT \* FROM p;**
last_arrival | hops | flights | level
--------------+---------------+-----------------+-------
UKX | {UKX} | {} | 1
KJA | {UKX,KJA} | {PG0022} | 2
UKX | {UKX,KJA,UKX} | {PG0022,PG0021} | 3
OVB | {UKX,KJA,OVB} | {PG0022,PG0206} | 3
OVB | {UKX,KJA,OVB} | {PG0022,PG0207} | 3
NOZ | {UKX,KJA,NOZ} | {PG0022,PG0351} | 3
NOZ | {UKX,KJA,NOZ} | {PG0022,PG0352} | 3
AER | {UKX,KJA,AER} | {PG0022,PG0501} | 3
SVO | {UKX,KJA,SVO} | {PG0022,PG0548} | 3
NUX | {UKX,KJA,NUX} | {PG0022,PG0623} | 3
UIK | {UKX,KJA,UIK} | {PG0022,PG0625} | 3
UIK | {UKX,KJA,UIK} | {PG0022,PG0626} | 3
BAX | {UKX,KJA,BAX} | {PG0022,PG0653} | 3
KRO | {UKX,KJA,KRO} | {PG0022,PG0673} | 3
OVS | {UKX,KJA,OVS} | {PG0022,PG0689} | 3
(15 rows)`
But another weirdness is worse. One of the rows shows that we can arrive back: {UKX,KJA,UKX}. And this means that we will infinitely fly in a circle, and the query will not terminate. It's this that explains hanging.
What shall we do with it? We need to add a condition that each airport can be visited not more than once (if this condition is not met, the route will not be optimal anyway).
`**demo=# WITH RECURSIVE p(last\_arrival, hops, flights, level) AS (
SELECT airport\_code,
ARRAY[airport\_code],
ARRAY[]::char(6)[],
1
FROM airports
WHERE airport\_code = 'UKX'
UNION ALL
SELECT r.arrival\_airport,
(p.hops || r.arrival\_airport)::char(3)[],
(p.flights || r.flight\_no)::char(6)[],
p.level + 1
FROM routes r, p
WHERE r.departure\_airport = p.last\_arrival
AND NOT r.arrival\_airport = ANY(p.hops)
AND p.level < 3
)
SELECT \* FROM p;**
last_arrival | hops | flights | level
--------------+---------------+-----------------+-------
UKX | {UKX} | {} | 1
KJA | {UKX,KJA} | {PG0022} | 2
OVB | {UKX,KJA,OVB} | {PG0022,PG0206} | 3
OVB | {UKX,KJA,OVB} | {PG0022,PG0207} | 3
NOZ | {UKX,KJA,NOZ} | {PG0022,PG0351} | 3
NOZ | {UKX,KJA,NOZ} | {PG0022,PG0352} | 3
AER | {UKX,KJA,AER} | {PG0022,PG0501} | 3
SVO | {UKX,KJA,SVO} | {PG0022,PG0548} | 3
NUX | {UKX,KJA,NUX} | {PG0022,PG0623} | 3
UIK | {UKX,KJA,UIK} | {PG0022,PG0625} | 3
UIK | {UKX,KJA,UIK} | {PG0022,PG0626} | 3
BAX | {UKX,KJA,BAX} | {PG0022,PG0653} | 3
KRO | {UKX,KJA,KRO} | {PG0022,PG0673} | 3
OVS | {UKX,KJA,OVS} | {PG0022,PG0689} | 3
(14 rows)`
Now it seems to be OK. Ready to run the query without limitations?
`**demo=# WITH RECURSIVE p(last\_arrival, hops, flights, level) AS (
SELECT airport\_code,
ARRAY[airport\_code],
ARRAY[]::char(6)[],
1
FROM airports
WHERE airport\_code = 'UKX'
UNION ALL
SELECT r.arrival\_airport,
(p.hops || r.arrival\_airport)::char(3)[],
(p.flights || r.flight\_no)::char(6)[],
p.level + 1
FROM routes r, p
WHERE r.departure\_airport = p.last\_arrival
AND NOT r.arrival\_airport = ANY(p.hops)
-- AND p.level < 3
)
SELECT \*
FROM p
WHERE p.last\_arrival = (
SELECT airport\_code FROM airports WHERE airport\_code = 'CNN'
);**`
Formally everything must be OK… but the query hangs again, and if we arm ourselves with patience, the query can fail with the error «out of space for temporary files».
Why does this happen? Because we have to create all possible routes of any length starting in A, and only at the very end we select those of them that end in B. This is, to say the least, not the most efficient algorithm. To understand «the extent of the disaster», we can start changing the limitations on `level` to see how many rows are returned in each step:
```
1 1
2 2
3 14
4 165
5 1978
6 22322
7 249942
8 2316063
```
And so on, and each next query is considerably slower than the previous one.
Let's think of the number that we expect to get in the answer to the problem. If there were only big cities, it's most likely 2 (with a connection in Moscow). In our situation, it makes sense to anticipate at least a couple more for regional flights to reach a big city. This makes around 4 or 5, or maybe 6. However, the query is not going to stop even at eight: it will reach (if it is strong and healthy enough) something around one hundred until it is unable to extend any chain!
Note that the algorithm is «width-first»: we add *all* routes having length 1, then *all* routes having length 2 and so on. That is, once we find just *any* route from A to B, it will be the shortest one (according to the number of connections). Now the only problem left is how to duly stop the exhaustive search.
The idea is that in each step we set the «route found» indicator if at least one of the just created routes ends in the destination. Then we will be able to write the stopping criterion.
Let's start with adding the destination to the query itself (earlier, it appeared only at the very end, when the results returned were filtered). Let's compute it at the very beginning and just leave it unchanged in the recursive term:
`**demo=# WITH RECURSIVE p(last\_arrival, destination, hops, flights, level) AS (
SELECT a\_from.airport\_code,
a\_to.airport\_code,
ARRAY[a\_from.airport\_code],
ARRAY[]::char(6)[],
1
FROM airports a\_from, airports a\_to
WHERE a\_from.airport\_code = 'UKX'
AND a\_to.airport\_code = 'CNN'
UNION ALL
SELECT r.arrival\_airport,
p.destination,
(p.hops || r.arrival\_airport)::char(3)[],
(p.flights || r.flight\_no)::char(6)[],
p.level + 1
FROM routes r, p
WHERE r.departure\_airport = p.hops[cardinality(p.hops)]
AND NOT r.arrival\_airport = ANY(p.hops)
AND p.level < 3
)
SELECT \* FROM p;**
last_arrival | destination | hops | flights | level
--------------+-------------+---------------+-----------------+-------
UKX | CNN | {UKX} | {} | 1
KJA | CNN | {UKX,KJA} | {PG0022} | 2
OVB | CNN | {UKX,KJA,OVB} | {PG0022,PG0206} | 3
OVB | CNN | {UKX,KJA,OVB} | {PG0022,PG0207} | 3
NOZ | CNN | {UKX,KJA,NOZ} | {PG0022,PG0351} | 3
NOZ | CNN | {UKX,KJA,NOZ} | {PG0022,PG0352} | 3
AER | CNN | {UKX,KJA,AER} | {PG0022,PG0501} | 3
SVO | CNN | {UKX,KJA,SVO} | {PG0022,PG0548} | 3
NUX | CNN | {UKX,KJA,NUX} | {PG0022,PG0623} | 3
UIK | CNN | {UKX,KJA,UIK} | {PG0022,PG0625} | 3
UIK | CNN | {UKX,KJA,UIK} | {PG0022,PG0626} | 3
BAX | CNN | {UKX,KJA,BAX} | {PG0022,PG0653} | 3
KRO | CNN | {UKX,KJA,KRO} | {PG0022,PG0673} | 3
OVS | CNN | {UKX,KJA,OVS} | {PG0022,PG0689} | 3
(14 rows)`
Now it is easy to compute the indicator of the found route: it must be set if the last point of the route is the same as the destination at least for one row. To this end, the window function `bool_or` will be useful (if window functions are something new to you, start with the [introduction](https://postgrespro.com/docs/postgresql/current/tutorial-window), which also contains references to a more detailed description).
`**demo=# WITH RECURSIVE p(last\_arrival, destination, hops, flights, found, level) AS (
SELECT a\_from.airport\_code,
a\_to.airport\_code,
ARRAY[a\_from.airport\_code],
ARRAY[]::char(6)[],
a\_from.airport\_code = a\_to.airport\_code,
1
FROM airports a\_from, airports a\_to
WHERE a\_from.airport\_code = 'UKX'
AND a\_to.airport\_code = 'OVB' -- CNN
UNION ALL
SELECT r.arrival\_airport,
p.destination,
(p.hops || r.arrival\_airport)::char(3)[],
(p.flights || r.flight\_no)::char(6)[],
bool\_or(r.arrival\_airport = p.destination) OVER (),
p.level + 1
FROM routes r, p
WHERE r.departure\_airport = p.last\_arrival
AND NOT r.arrival\_airport = ANY(p.hops)
AND p.level < 3
)
SELECT \* FROM p;**
last_arrival | destination | hops | flights | found | level
--------------+-------------+---------------+-----------------+-------+-------
UKX | OVB | {UKX} | {} | f | 1
KJA | OVB | {UKX,KJA} | {PG0022} | f | 2
OVB | OVB | {UKX,KJA,OVB} | {PG0022,PG0206} | t | 3
OVB | OVB | {UKX,KJA,OVB} | {PG0022,PG0207} | t | 3
NOZ | OVB | {UKX,KJA,NOZ} | {PG0022,PG0351} | t | 3
NOZ | OVB | {UKX,KJA,NOZ} | {PG0022,PG0352} | t | 3
AER | OVB | {UKX,KJA,AER} | {PG0022,PG0501} | t | 3
SVO | OVB | {UKX,KJA,SVO} | {PG0022,PG0548} | t | 3
NUX | OVB | {UKX,KJA,NUX} | {PG0022,PG0623} | t | 3
UIK | OVB | {UKX,KJA,UIK} | {PG0022,PG0625} | t | 3
UIK | OVB | {UKX,KJA,UIK} | {PG0022,PG0626} | t | 3
BAX | OVB | {UKX,KJA,BAX} | {PG0022,PG0653} | t | 3
KRO | OVB | {UKX,KJA,KRO} | {PG0022,PG0673} | t | 3
OVS | OVB | {UKX,KJA,OVS} | {PG0022,PG0689} | t | 3
(14 rows)`
Here we checked how the query will work for the route from Ust-Kut (UKX) to Novosibirsk (OVB), which, as we already know, has length 3. (By the way, to this end, we had to change CNN to OVB only once — every little bit helps.) This does work!
We also compute the indicator in the non-recursive term of the query. We could just write `false`, but this way the query will be more universal and will correctly compute the number of connections from A back to A.
Now we only need to add the stopping criterion, and we can run the query:
`**demo=# WITH RECURSIVE p(last\_arrival, destination, hops, flights, found, level) AS (
SELECT a\_from.airport\_code,
a\_to.airport\_code,
ARRAY[a\_from.airport\_code],
ARRAY[]::char(6)[],
a\_from.airport\_code = a\_to.airport\_code,
1
FROM airports a\_from, airports a\_to
WHERE a\_from.airport\_code = 'UKX'
AND a\_to.airport\_code = 'CNN'
UNION ALL
SELECT r.arrival\_airport,
p.destination,
(p.hops || r.arrival\_airport)::char(3)[],
(p.flights || r.flight\_no)::char(6)[],
bool\_or(r.arrival\_airport = p.destination) OVER (),
p.level + 1
FROM routes r, p
WHERE r.departure\_airport = p.last\_arrival
AND NOT r.arrival\_airport = ANY(p.hops)
AND NOT p.found
-- AND p.level < 3
)
SELECT hops, flights
FROM p
WHERE p.last\_arrival = p.destination;**
hops | flights
-----------------------+-------------------------------
{UKX,KJA,OVB,MJZ,CNN} | {PG0022,PG0206,PG0390,PG0035}
{UKX,KJA,OVB,MJZ,CNN} | {PG0022,PG0207,PG0390,PG0035}
{UKX,KJA,SVO,MJZ,CNN} | {PG0022,PG0548,PG0120,PG0035}
{UKX,KJA,OVB,MJZ,CNN} | {PG0022,PG0206,PG0390,PG0036}
{UKX,KJA,OVB,MJZ,CNN} | {PG0022,PG0207,PG0390,PG0036}
{UKX,KJA,SVO,MJZ,CNN} | {PG0022,PG0548,PG0120,PG0036}
{UKX,KJA,OVS,LED,CNN} | {PG0022,PG0689,PG0686,PG0245}
{UKX,KJA,SVO,LED,CNN} | {PG0022,PG0548,PG0472,PG0245}
{UKX,KJA,SVO,LED,CNN} | {PG0022,PG0548,PG0471,PG0245}
{UKX,KJA,SVO,LED,CNN} | {PG0022,PG0548,PG0470,PG0245}
{UKX,KJA,SVO,LED,CNN} | {PG0022,PG0548,PG0469,PG0245}
{UKX,KJA,SVO,LED,CNN} | {PG0022,PG0548,PG0468,PG0245}
{UKX,KJA,OVB,PEE,CNN} | {PG0022,PG0206,PG0186,PG0394}
{UKX,KJA,OVB,PEE,CNN} | {PG0022,PG0207,PG0186,PG0394}
{UKX,KJA,BAX,ASF,CNN} | {PG0022,PG0653,PG0595,PG0427}
{UKX,KJA,SVO,ASF,CNN} | {PG0022,PG0548,PG0128,PG0427}
{UKX,KJA,OVS,DME,CNN} | {PG0022,PG0689,PG0544,PG0709}
{UKX,KJA,OVS,DME,CNN} | {PG0022,PG0689,PG0543,PG0709}
{UKX,KJA,KRO,DME,CNN} | {PG0022,PG0673,PG0371,PG0709}
{UKX,KJA,OVB,DME,CNN} | {PG0022,PG0206,PG0223,PG0709}
{UKX,KJA,OVB,DME,CNN} | {PG0022,PG0207,PG0223,PG0709}
{UKX,KJA,NUX,DME,CNN} | {PG0022,PG0623,PG0165,PG0709}
{UKX,KJA,BAX,DME,CNN} | {PG0022,PG0653,PG0117,PG0709}
(23 rows)`
That's actually all. We arrived at the query shown at the beginning of the article, and it runs instantaneously. We can now remove the «debugging» `level`… or we can leave it.
Let's summarize useful techniques:
* It often helps to represent a «route» as an array. We can concatenate rows instead, but it is not so convenient.
* Preventing infinite loops (also by means of the array).
* Debugging by limiting the number of iterations.
* Sometimes a way to duly stop is needed for better performance.
* Window functions enable working miracles.
For exercises
-------------
To reinforce the skill, you can do a few variations on the theme:
1. What is the maximum number of connections needed to fly from any airport to any other?
Hint 1: the first term of the query must contain all pairs of departure and arrival airports.
Hint 2: you need to compute the indicator of the found route separately for each pair of airports.
2. Find the route (from UKX to CNN) with the minimum total duration of the flights (not counting the waits for connection flights).
Hint 1: this route may appear not to have the optimal number of connections.
Hint 2: you need to think up an indicator to signal that further exhaustive search is useless.
3. Find the route (from UKX to CNN) with the minimum total duration of the flights, *including* the waits for connection flights. Assume that we are ready for the first departure at the moment of `**bookings.now() - interval '20 days'**`.
When you master the third task, share your success with us ([edu@postgrespro.ru](mailto:edu@postgrespro.ru))! | https://habr.com/ru/post/490228/ | null | en | null |
# Инверсия зависимости и System.Data.Common.DbDataReader
Если мы не используем EF (такое случается), то нам нужно как-то устроить загрузку объектов из базы данных. Вариант: берём `DataSet`, делаем ему `SomeDataAdapter.fill(...)`, а из него берём данные для строительства нужных объектов. При этом класс, который умеет заполнять `DataSet`, не знает, для объектов какого класса он это делает. Абстракция, низкая связанность, всё хорошо.
Однако, мы ждём, пока заполнится `DataSet`, только после этого можем начать отправку ответа клиенту.
Ранее в публикации [JSON-сериализация асинхронного стрима](https://habr.com/ru/post/656723/) мы рассмотрели способ, как отправлять данные по мере поступления с помощью `SomeDataReader` (например, `OracleDataReader`). Там был приведён пример:
```
private async IAsyncEnumerable GetCatsList()
{
using OracleConnection conn = GetConnection();
var taskOpenConnection = conn.OpenAsync();
OracleCommand command = conn.CreateCommand();
command.CommandText = "select STRING\_ID, INT\_ID, breed, name from T\_CATS";
await taskOpenConnection;
OracleDataReader dataReader = (OracleDataReader) await command.ExecuteReaderAsync();
while (true)
{
Task canRead = dataReader.ReadAsync();
Cat item = new();
item.Id = new StringIntId();
if(! await canRead)
{
yield break;
}
item.Id.StringId = dataReader["STRING\_ID"].ToString()!.Trim();
item.Id.IntId = int.Parse(dataReader["INT\_ID"].ToString()!.Trim());
item.Breed = dataReader["BREED"].ToString()!.Trim();
item.Name = dataReader["NANE"].ToString()!.Trim();
yield return item;
}
}
...
public async Task GetCats(HttpContext httpContext)
{
await httpContext.Response.WriteAsJsonAsync(
GetCatsList(),
new JsonSerializerOptions { PropertyNameCaseInsensitive = false }
);
}
```
И так делать, конечно, некрасиво. Потому что в таком случае у нас класс, который умеет работать с базой данных зависит от интерфейса `ICatForListing` и класса `Cat`, относящихся к бизнес-модели.
Можно получить абстрактный DbDataReader и крутить его уже на более высоком уровне(спасибо @Ordos):
```
// низкоуровневый класс, работающий с базой данных
public class Database
{
public async Task GetCatsDataReader()
{
OracleConnection conn = GetConnection();
var taskOpenConnection = conn.OpenAsync();
OracleCommand command = conn.CreateCommand();
command.CommandText = "select STRING\_ID, INT\_ID, breed, name from T\_CATS";
await taskOpenConnection;
return await command.ExecuteReaderAsync(
System.Data.CommandBehavior.CloseConnection);
}
}
// контроллер ASP.NET
public class CatsController
{
private Database \_database = new();
private async IAsyncEnumerable GetCatsList()
{
using DbDataReader dataReader = await \_database.GetCatsDataReader();
while (true)
{
Task canRead = dataReader.ReadAsync();
Cat item = new();
item.Id = new StringIntId();
if(! await canRead)
{
yield break;
}
item.Id.StringId = dataReader["STRING\_ID"].ToString()!.Trim();
item.Id.IntId = int.Parse(dataReader["INT\_ID"].ToString()!.Trim());
item.Breed = dataReader["BREED"].ToString()!.Trim();
item.Name = dataReader["NANE"].ToString()!.Trim();
yield return item;
}
}
...
public async Task GetCats(HttpContext httpContext)
{
await httpContext.Response.WriteAsJsonAsync(
GetCatsList(),
new JsonSerializerOptions { PropertyNameCaseInsensitive = false }
);
}
}
```
Кроме этого, можно возвращать DbDataReader через `IAsyncEnumerable`:
```
// низкоуровневый класс, работающий с базой данных
public class Database
{
public async IAsyncEnumerable GetCatsDataReader()
{
using OracleConnection conn = GetConnection();
var taskOpenConnection = conn.OpenAsync();
OracleCommand command = conn.CreateCommand();
command.CommandText = "select STRING\_ID, INT\_ID, breed, name from T\_CATS";
await taskOpenConnection;
using OracleDataReader dr = (OracleDataReader) await cmd.ExecuteReaderAsync();
while (await dr.ReadAsync())
{
yield return (DbDataReader)dr;
}
}
}
// контроллер ASP.NET
public class CatsController
{
private Database \_database = new();
private async IAsyncEnumerable GetCatsList()
{
await foreach (DbDataReader dataReader in GetCatsDataReader())
{
Cat item = new();
item.Id = new StringIntId();
item.Id.StringId = dataReader["STRING\_ID"].ToString()!.Trim();
item.Id.IntId = int.Parse(dataReader["INT\_ID"].ToString()!.Trim());
item.Breed = dataReader["BREED"].ToString()!.Trim();
item.Name = dataReader["NANE"].ToString()!.Trim();
yield return item;
}
}
...
public async Task GetCats(HttpContext httpContext)
{
await httpContext.Response.WriteAsJsonAsync(
GetCatsList(),
new JsonSerializerOptions { PropertyNameCaseInsensitive = false }
);
}
}
```
Оба метода работают. | https://habr.com/ru/post/662976/ | null | ru | null |
# Zend_Form, русификация сообщений об ошибках
Публикую не свою статью. Вот ссылка на оригинал — <http://web-blog.org.ua/articles/uchim-zend-form-russkomu-yazuky> Но эта ссылка нерабочая.
Поэтому во избежание пропадания такой ценной, на мой взгляд, информации, я решила ее перепостить еще и сюда. Надеюсь автор не будет против.
Всю статью решила не писать, а только запостить полезный код. Тем, кому нужно будет решить такую проблему — все поймут.
`// Массив переведённых сообщений
$data = array(
Zend_Validate_Alnum::NOT_ALNUM => 'Введенное значение "%value%" неправильное. Разрешены только латинские символы и цифры',
Zend_Validate_Alnum::STRING_EMPTY => 'Поле не может быть пустым. Заполните его, пожалуйста',
Zend_Validate_Alpha::NOT_ALPHA => 'Введите в это поле только латинские символы',
Zend_Validate_Alpha::STRING_EMPTY => 'Поле не может быть пустым. Заполните его, пожалуйста',
Zend_Validate_Barcode_UpcA::INVALID => '"%value% неправильный UPC-A штрих-код"',
Zend_Validate_Barcode_UpcA::INVALID_LENGTH => 'Неправильное значение "%value%". Введите 12 символов',
Zend_Validate_Barcode_Ean13::INVALID => '"%value% неправильный EAN-13 штрих-код',
Zend_Validate_Barcode_Ean13::INVALID_LENGTH => 'Неправильное значение "%value%". Введите 13 символов',
Zend_Validate_Between::NOT_BETWEEN => '"%value%" не находится между "%min%" и "%max%", включительно',
Zend_Validate_Between::NOT_BETWEEN_STRICT => '"%value%" не находится строго между "%min%" и "%max%"',
Zend_Validate_Ccnum::LENGTH => '"%value%" должно быть численным значением от 13 до 19 цифр длинной',
Zend_Validate_Ccnum::CHECKSUM => 'Подсчёт контрольной суммы неудался. Значение "%value%" неверно',
Zend_Validate_Date::NOT_YYYY_MM_DD => '"%value%" не подходит под формат год-месяц-день(напр. 2008-11-03)',
Zend_Validate_Date::INVALID => '"%value%" - неверная дата',
Zend_Validate_Date::FALSEFORMAT => '"%value%" - не подходит по формату',
Zend_Validate_Digits::NOT_DIGITS => 'Значение "%value%" неправильное. Введите только цифры',
Zend_Validate_Digits::STRING_EMPTY => 'Поле не может быть пустым. Заполните его, пожалуйста',
Zend_Validate_EmailAddress::INVALID => '"%value%" неправильный адрес електронной почты. Введите его в формате имя@домен',
Zend_Validate_EmailAddress::INVALID_HOSTNAME => '"%hostname%" неверный домен для адреса "%value%"',
Zend_Validate_EmailAddress::INVALID_MX_RECORD => 'Домен "%hostname%" не имеет MX-записи об адресе "%value%"',
Zend_Validate_EmailAddress::DOT_ATOM => '"%localPart%" не соответствует формату dot-atom',
Zend_Validate_EmailAddress::QUOTED_STRING => '"%localPart%" не соответствует формату указанной строки',
Zend_Validate_EmailAddress::INVALID_LOCAL_PART => '"%localPart%" не правильное имя для адреса "%value%", вводите адрес вида имя@домен',
Zend_Validate_Float::NOT_FLOAT => '"%value%" не является дробным числом',
Zend_Validate_GreaterThan::NOT_GREATER => '"%value%" не превышает "%min%"',
Zend_Validate_Hex::NOT_HEX => '"%value%" содержит в себе не только шестнадцатеричные символы',
Zend_Validate_Hostname::IP_ADDRESS_NOT_ALLOWED => '"%value%" - это IP-адрес, но IP-адреса не разрешены ',
Zend_Validate_Hostname::UNKNOWN_TLD => '"%value%" - это DNS имя хоста, но оно не дожно быть из TLD-списка',
Zend_Validate_Hostname::INVALID_DASH => '"%value%" - это DNS имя хоста, но знак "-" находится в неправильном месте',
Zend_Validate_Hostname::INVALID_HOSTNAME_SCHEMA => '"%value%" - это DNS имя хоста, но оно не соответствует TLD для TLD "%tld%"',
Zend_Validate_Hostname::UNDECIPHERABLE_TLD => '"%value%" - это DNS имя хоста. Не удаётся извлечь TLD часть',
Zend_Validate_Hostname::INVALID_HOSTNAME => '"%value%" - не соответствует ожидаемой структуре для DNS имени хоста',
Zend_Validate_Hostname::INVALID_LOCAL_NAME => '"%value%" - адрес является недопустимым локальным сетевым адресом',
Zend_Validate_Hostname::LOCAL_NAME_NOT_ALLOWED => '"%value%" - адрес является сетевым расположением, но локальные сетевые адреса не разрешены',
Zend_Validate_Identical::NOT_SAME => 'Значения не совпадают',
Zend_Validate_Identical::MISSING_TOKEN => 'Не было введено значения для проверки на идентичность',
Zend_Validate_InArray::NOT_IN_ARRAY => '"%value%" не найдено в перечисленных допустимых значениях',
Zend_Validate_Int::NOT_INT => '"%value%" не является целочисленным значением',
Zend_Validate_Ip::NOT_IP_ADDRESS => '"%value%" не является правильным IP-адресом',
Zend_Validate_LessThan::NOT_LESS => '"%value%" не меньше, чем "%max%"',
Zend_Validate_NotEmpty::IS_EMPTY => 'Введённое значение пустое, заполните поле, пожалуйста',
Zend_Validate_Regex::NOT_MATCH => 'Значение "%value%" не подходит под шаблон регулярного выражения "%pattern%"',
Zend_Validate_StringLength::TOO_SHORT => 'Длина введённого значения "%value%", меньше чем %min% симв.',
Zend_Validate_StringLength::TOO_LONG => 'Длина введённого значения "%value%", больше чем %max% симв.',
);
// создаём экземпляр Zend_Translate, используя адаптер Array
$translator = new Zend_Translate_Adapter_Array($data);
// создаём нашу форму
$form = new Zend_Form();
// передаём ей наш Zend_Translate
$form->setTranslator($translator);
/**
* Исполняем другой код, напр., настраиваем форму
*/`
Для себя сделала чуть по-другому — унаследовала класс Zend\_Form и все это проделала в его конструкторе, теперь использую его.
`class My_Form extends Zend_Form {
public function __construct() {
parent::__construct();
$data = array(
...
...
...
);
$translator = new Zend_Translate_Adapter_Array($data);
$this->setTranslator($translator);
}
}`
Вопрос для знатоков ZF — может есть способ поаккуратнее это сделать? Например через статические какие-то методы установить переводы для валидаторов форм для всего приложения? | https://habr.com/ru/post/70386/ | null | ru | null |
# Скрещиваем WebWorker и Promise
Если уж есть необходимость скрещивать WebWorker с [XMLHttpRequest](http://habrahabr.ru/post/218989/), то пора бы скрестить его с любой функцией, а заодно разобраться с [обещаниями ES6](http://www.html5rocks.com/en/tutorials/es6/promises/).
Цель — научиться делать вот так:
`new PromiseWorker(array => array.sort()).Invoke([3,2,1]).then(result => console.log(result));`
(Здесь и далее используются [arrow functions](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/arrow_functions) для краткости)
Как известно, true-way для создания воркера — передать путь к файлу в качестве единственного параметра: `new Worker("/JS/worker.js")` . повесить обработчик onmessage, вызывать postmessage и придерживаться подобного стиля в файле воркера. По моему мнению на одну функцию слишком жирно создавать целый файл, да и возиться с событиями-обработчиками уже не комильфо. Хорошо, что есть [Blob](https://developer.mozilla.org/en-US/docs/Web/API/Blob) и уже упомянутые Promises.
Сначала надо сделать преобразование входной функции в приемлемый для воркера вид:
```
var FnToWorker = fn => {
var workerBody = "self.addEventListener('message'," +
"function (d) {" +
"var result;" +
"try {" +
"result = (" + fn.toString() + ")(d.data.Data);" +
"self.postMessage({ Result: result, Id: d.data.Id });" +
"} catch (e) {" +
"self.postMessage({ Error: e, Id: d.data.Id });" +
"}" +
"});"
var worker = new Worker(URL.createObjectURL(new Blob([workerBody])));
return worker;
}
```
Да, тут отвратительная конкатенация строк, fn.toString() и прочие ужасные вещи… главное что этот код можно один раз написать и забыть о нем.
Как указали в комментариях, данная конструкция накладывает некоторые ограничения: функция должна не иметь внешних зависимостей (переменные замыкания, не[разрешенные](https://developer.mozilla.org/en-US/docs/Web/Reference/Functions_and_classes_available_to_workers) для воркеров объекты window), т.к. к ним не будет доступа из потока воркера. Функции, созданные с помощью системных функций (например, Function.prototype.bind), не могут быть использованы в воркерах из-за того, что fn.toString() не вернет тело функции.
Вот так будет выглядеть Invoke:
```
var promises = []; //Очередь вызовов
var Invoke = data => {
var message = { Data: data, Id: performance.now() }; //У каждого сообщения Id, чтобы ничего не путалось
var p = new Promise((resolve, reject) => {
promises[message.Id] = { resolve: resolve, reject: reject };
});
worker.postMessage(message); //Запускаем воркер
return p;
}
```
Использовать Promise не сложно: в конструктор передаем функцию от двух аргументов: resolve и reject. Это функции которые надо будет вызвать в случае успеха операции и неуспеха соответственно. В нашем случае они будут вызываться после того, как отработает воркер:
```
var OnMessage = data => {
if (data.data.Error) {
promises[data.data.Id].reject(data.data.Result);
} else {
promises[data.data.Id].resolve(data.data.Result);
}
promises[data.data.Id] = undefined;
}
```
Ну и вот так оно будет выглядеть в сборе: <http://jsfiddle.net/sXJ4M/1/>
Конечно, сложно себе представить, где можно использовать воркеры в интернет-магазине, но в достаточно больших и сложных приложениях они очень помогают. | https://habr.com/ru/post/219037/ | null | ru | null |
# Еще к вопросу о множествах
#### Алиса: А почему это место ОЧЕНЬ странное место?
Додо: А потому, что все остальные места — очень уж не странные. Должно же быть хоть одно ОЧЕНЬ странное место.
Итак, рассмотрим текст шаблонного класса BitSet с целью его адаптации к требованиям МК, основные направления оптимизации были определены ранее. Можно, конечно, написать свой собственный класс с нуля, но не будем пренебрегать возможностью ознакомиться с хорошими решениями, ведь библиотека STL (не путать с spl) известна давно и используется повсеместно. Для начала следует найти исходный код, после недолгого странствия по Инету я просто открыл директорию с моим MinGW и разыскал требуемый файл, который и намерен далее обсуждать.
В начале мы видим чуть более страницы с копирайтом и текстом лицензии, а также разнообразные предупреждениями — ну это можно пропустить, это для юристов. Далее идут инклуды и я выражаю благодарность авторам — каждый сопровождается комментарием, о том, что мы хотим получить из каждого файла — все бы так делали, работа ~~Индианы Джонса~~ исследователя была бы проще. Далее идут дефайны, я не фанатик чистоты кода и не буду спорить — пусть будут и сразу же вижу определении числа битов в единице хранения, которой является unsigned long. Продолжая движение по скользкому пути дефайнов, завожу свое определение единицы хранения, которая приравнивается uint8\_fast, хотя и понимаю, что этого будет явно недостаточно. Кстати, сразу приношу еще одну благодарность авторам за стиль — в конце модуля они убирают за собой, уничтожая внутренние дефайны — уже и не надеялся, что увижу такое в современном продакшене.
А вот дальше начинаются легкие непонятки — вначале определяют шаблонную вспомогательную структуру struct \_Base\_bitset (почему именно структуру, а не класс, раз уж они взаимозаменяемы), в которой определяют тип для хранения данных и он опять указан напрямую — меняем на свой. Далее определяют два инстанцирования этой вспомогательной структуры — для одной единицы хранения (ну это понятно, для повышения эффективности кода) и для вырожденного примера без хранения вообще (наверное, для обработки ошибок), пока не трогаем этот код.
Далее обнаруживаем основной класс class bitset (теперь именно класс), производный от шаблонной структуры (да, в С так можно, непонятно, зачем так делать, но можно), в котором опять определяется тип хранения и опять меняем на свой. Но здесь я задумался — а почему тип не наследовался от родительской структуры и с изумлением обнаружил (да с изумлением, шаблонные классы — это не то, чем я занимаюсь в повседневной жизни), что наследование шаблонных классов несколько отлично от обычных. То есть наследование как раз такое же и все сущности родителя доступны в дочернем (надеюсь, никто не примет меня за гендерного шовиниста) классе, но их необходимо указывать с полным именем. Ну это еще можно понять, иначе компилятор не догадается, какой из инстанцированных вариантов применить, но в случае использования определенных в классе типов надо еще добавить ключевое слово typename. Совершенно не очевидное решение, особенно меня порадовала диагностика компилятора, в переводе означающая «может быть, вы имели в виду тип из родительского класса» — да, спасибо капитан, именно его я и имел в виду, рад, что мы понимаем друг друга, но мне легче не становится. Впрочем, такая диагностика имеет место в старой версии GCC, в текущей сообщение становится более понятным «возможно, вы забыли ключевое слово typename». Понимание диагностических сообщений компилятора для шаблонных классов — это вообще тема отдельной песни, и песня эта отнюдь не радостная.
Так что, если мы не хотим в дочернем классе постоянно использовать конструкцию
```
std::_Base_bitset::\_WordT
```
(а мы не хотим, нег?) то у нас есть три пути
1) тривиальный
```
#define _WordT typename _Base_bitset<_Nb>::_WordT
```
2) очевидный – определение типа на глобальном уровне и мне больше понравился
3) для любителей странного
```
typedef typename _Base_bitset<_Nb>::_WordT _WordT;
```
(стойкое ощущение великолепного хромированного костылика). Лично меня во всех трех случаях не устраивает прямое указание класса-родителя, ведь реализация не должна учитывать цепочку наследования, но может быть, я чего-то не понимаю.
Есть еще и метод 4)
```
using _WordT = std::_Base_bitset::\_WordT;
```
но в моей версии компилятора он не работает, так что его нет.
Примечание на полях (Пнп)- в замечательной книге «C++ for real programmers» (в свое время я ее закачал по ошибке, решив, что она посвящена С++ в реал-тайм системах) про язык сказано «Его элегантность заключается отнюдь не в простоте (слова С++ и простота режут слух своим явным противоречием), а в его потенциальных возможностях. За каждой уродливой проблемой прячется какая-нибудь умная идиома, изящный языковой финт, благодаря которому проблема тает прямо на глазах.» Поскольку книга действительно замечательная, значит и приведенная цитата верна (понимаю, что тут есть определенная логическая натяжка), но лично я, к сожалению, проблему вижу, а с умной идиомой напряженка.
Несмотря на оставшееся чувство легкого недоумения, задача решена и можно наслаждаться результатом — но не тут то было. При изменении размера тестового множества с 15 на 5 совершенно неожиданно возникла ошибка компиляции. Нет, все понятно, сработала не модифицированная инстанцинация с параметром шаблона 1, но со стороны выглядит это весьма странно — меняем константу и программа перестает компилироваться.
Можно, конечно, модифицировать и эту реализацию и другую, но выглядит такой подход, как грубое нарушение принципа DRY. Возможные решения есть и их более одного 1) очевидное – опять дефайн и 2) тривиальное – опять определение типа на глобальном уровне, но в этом случае он вылезет за пределы модуля, что, впрочем, он делает и в рассматриваемой реализации, высовываясь из базовой структуры, только еще и квалификатор писать будет не нужно.
Поэтому я склоняюсь к варианту 3) базовый класс для определения типа и наследование всех инстанцинаций от него. Причем сущности родительского класса защищенные, опять-таки, чтобы они не торчали наружу. Далее обнаруживаю забавное свойство, наверное, тут надо похвалить С++ за гибкость — для варианта с отсутствующим хранением тип не нужен, и язык позволяет использовать реализацию без наследования, хотя это и не особо нужно в данном конкретном случае. Сразу же обнаруживаю еще один недостаток библиотеки — во всех трех вариантах каждый раз задаются операции вычисления номера единицы хранения
```
static size_t _S_whichword
```
и маски бита в ней \_S\_maskbit и они совершенно идентичны — выносим их тоже в базовый класс. При этом обнаруживается «мертвый» код – метод \_S\_whichbyte, даже и не знаю что делать — с одной стороны, правила хорошего тона требуют его удаления, с другой — в случае шаблона это никак не сказывается на результирующем коде. Воспользуюсь правилом — «не понимаешь чего то — не трогай» и оставлю этот метод.
В принципе, модификации с точки зрения типа хранения закончены и можно приступать к тестированию. И сразу же обнаруживаю недостаток реализации — для архитектуры MSP430 почему то выделяются двух-байтовые слова вместо байтов. Конечно, не двойные слова, как раньше, но все-таки мы боремся за минимальный (во всех смыслах) код. Оказывается, компилятор уверен, что в этой архитектуре тип uint\_fast8\_t имеет размер 2, хотя в системе команд имеются операции работы с байтами и сам компилятор их вполне использует. Идея с использованием данного типа скомпрометирована и приходится задавать тип данных uint8\_t напрямую. Ну что же, если найдется архитектура, в которой работа с байтами реализована неудачно и размер типа uint\_fast8\_t отличен от 1 (из имеющихся в компиляторе таковых не обнаружено), ей придется страдать ради быстродействия всех остальных.
Тестирование исправленной версии показывает ее правильную работу на различных архитектурах и с разными параметрами, но остался еще вопрос с вычислением битовых масок для МК без развитых сдвигов, в нашем случае это MSP430 и AVR. В принципе, можно просто сделать чтение битовой маски из массива методом для всех случаев, невзирая на архитектуру МК. Решение вполне себе рабочее, у развитых архитектур с индексированием все нормально, но все равно будет проигрыш по времени по сравнению с быстрыми сдвигами, а не хотелось бы, чтобы в мою сторону тыкали пальцами со словами «класс будет быстрее, говорил он, мы оптимизируем, говорил он».
Поэтому нам нужна различная реализация для наших двух слабых архитектур, которые отличаются от всех остальных размером типа uint\_fast16\_t — он составляет 2 против 4, либо 8 у 64 разрядных версий. Условная компиляция нам не поможет, а ставить условие в надежде на оптимизацию — это не путь самурая, остаются шаблоны. Пытаюсь создать шаблонный метод класса, но частичная специализация для него недоступна — оказывается, так и должно быть и даже нахожу статью, в которой написано, почему это хорошее решение. Честно говоря, я так и не понял, почему это решение хорошее, скорее всего, это обусловлено религиозными соображениями. Тем не менее, нас не спросили, и что остается делать — можно сделать дружественную шаблонную функцию (оказалось, что нельзя, причем по той же причине — запрещена частичная специализация), есть еще одно решение, выглядит забавно — частичная специализация метода вне тела класса. Можно вообще создать отдельную шаблонную функцию и обращаться к ней из методов класса, не знаю, какой способ правильнее, я выбрал именно этот. Да, она не имеет доступа к внутренним сущностям класса, но в данном конкретном случае это и не надо, что делать, если это потребуется, я пока не знаю, «будем решать проблемы по мере их возникновения».
Теперь у нас есть все необходимое, собираем оттестированные фрагменты вместе и получаем код, решающий изначально поставленную задачу оптимизации. Заодно мы сделали код компактнее (а значит, понятнее, хотя последнее спорно), убрали многочисленные повторы и исключили торчащие наружу избыточные сущности. Единственное, что не исправлено — это смешение структур и классов, но тут я не понимаю причины подобной реализации, поэтому, на всякий случай, трогать эту часть не буду.
Реализации второго варианта множества будет посвящен отдельный пост, и без того что-то много получилось. | https://habr.com/ru/post/450176/ | null | ru | null |
# Структурная модель СКУД предприятия с арендаторами и их клиентами
На одном предприятии, основным видом деятельности которого является предоставление офисов и складских услуг, возникла необходимость установить СКУД. Клиентами предприятия являются организации и индивидуальные предприниматели, занимающиеся торгово-закупочной и производственной деятельностью. В свою очередь, они имеют большое количество собственных клиентов.
Требования к системе, помимо обычных требований по учету рабочего времени сотрудников арендодателя и арендаторов, включают требования по контролю за клиентами арендаторами, в плане запрета вывоза товаров без отметки об оплате или разрешении на вывоз. Также, необходимо учесть наличие совместителей как на основном предприятии, так и у арендаторов.
#### Особенности структурной модели
Построим структурную модель СКУД на территорию с одной точкой доступа. Любая точка доступа оборудуется замком, для открытия которого имеется набор ключей. Простейшая модель такой системы включает в себя четыре сущности, играющие определенные роли, например, для квартиры с одной входной дверью:
Однако, даже при самом подробном описании сущностей, они не являются моделью системы, потому что между ними нет связей. Например, описывая дверь, мы должны знать к какой она относится квартире. Устанавливая связи между сущностями (объектами), мы фиксируем результат взаимодействия между ними и задаем связь как набор атрибутов: дверь в квартиру установлена 01.01.2000 (атрибут Дата), замок на двери установлен 02.01.2000 (атрибут Дата) мастером Петровым П.П. (атрибут Мастер).
Так как у каждого из связанных объектов может быть свой «взгляд» на связь между ними, то нужно рассматривать две связи. Например, связь **Замок#Двери** это набор атрибутов,
```
{"Имя связи", "Дата установки замка", "Кем установлен замок"}
```
а связь **Двери#Замок** — набор атрибутов
```
{"Имя связи", "Дата установки замка", "Кем установлен замок", ["Координаты установки замка"]}
```
Установка второго замка на дверь, означает появление не только нового экземпляра сущности (без изменения ее роли), но и изменения ее «размерности» — с одномерной **Замок**, на многомерную **Замки**. Точно также установка второй двери изменит «размерность» соответствующей сущности:
Сохранение ролей при изменении сущностей (например, их размерности) определяет сохранение и структуры связей между ними. Мы по-прежнему рассматриваем по две связи между многомерными сущностями (объектами), но сами связи становятся многомерными, причем количество компонентов у связи **Замок#Двери** равно количеству замков в системе, а у связи **Двери#Замок** — количеству дверей.
Наиболее интересными связями с точки зрения СКУД являются связи между объектом **Ключи** и объектом **Замки** (ролями Идентификатор и Преграждающее устройство). Именно в этих связях можно вести учет в какой момент какой замок открывался или закрывался и каким ключом. Связь **Ключи#Замки**, например,
может иметь вид:
```
[{"Имя связи", "Операция (открытие/закрытие)", "Время начала операции"}, {}, ..., {}]
```
Связь **Замки#Ключи**, в свою очередь, может иметь атрибуты, связанные с моментами получения ключей, их утери и замены.
В любом, случае к объектам мы относим элементы системы, чьи атрибуты практически не изменяются за время наблюдения за ней, в отличие от связей, чьи атрибуты за это же время могут существенно изменится. Выбор набора атрибутов для элементов системы целиком определяется конструктором системы при ее моделировании.
#### Роли и объекты структурной модели
В реальной СКУД нужно учитывать ряд новых ролей и объектов их исполняющих. Добавим в структурную модель нужно роль **Владелец** идентификатора, объект, исполняющий эту роль, назовем **Посетителем**, а также изменим исполнителей некоторых ролей:
Связь **Метки#Посетители**:
```
[{ "Имя связи", "Имя посетителя", "Тип метки": (Постоянный, Временный, Разовый) ", "Дата начала владения", "Дата окончания владения", "Статус метки": (Активный, Неактивный)}, ...]
```
Такая связь позволяет:
однозначно идентифицировать посетителя по метке (только одна запись в связи может иметь Статус метки=Активный);
выдавать сотруднику разовый или однодневный временный пропуск взамен забытого;
задавать срок действия временного пропуска.
Связь **Посетители#Метки**:
```
[{"Имя связи", "Имя метки", "Причина добавления новой метки"}, ...]
```
Такая связь позволяет организовать, например, начисление штрафных баллов на сотрудника, потерявшего карту доступа или регулярно ее забывающего.
Связь **Считыватели#Метки**:
```
[{ "Имя связи", "Имя метки", "Статус метки": (Вход разрешен, Вход запрещен, Выход разрешен, Выход запрещен), "Время считывания"}, ...]
```
Такая связь позволяет вести журнал учета событий со считывателем.
Связь **Метки#Считыватели** устанавливать не будем, так как для нее нет значимых атрибутов.
Получение статуса Вход разрешен, еще не означает, что вход состоялся. Для того, чтобы отобразить атрибуты связанные с переходом добавим связи между метками и турникетом.
Связь между меткой и считывателем должна показывать какая метка каким считывателем и когда определяется, а также фиксировать статус метки.
Связь **Метки#Турникет**:
```
[{ "Имя связи", "Имя Турникета", "Направление": (Вход, Выход), "Время перехода"}, ...]
```
Такая связь позволяет вести учет переходов через турникет каждым посетителем в соответствии с его меткой.
Связь **Турникет#Метки**:
```
{ "Имя связи", ["Имя Метки", "Направление": (Вход, Выход, Не определено), "Время перехода"]}
```
Такая связь позволяет вести журнал посетителей и переходов. Если невозможно определить направление перехода (турникет открыт кнопками в обоих направлениях), а переход осуществлен, в связи указывается время перехода с неопределенным направлением и пустым именем метки.
Связи между турникетом и считывателями, а также турникетом и зоной доступа могут использоваться для учета эксплуатации устройств, например, связь **Турникет#Считыватели**:
```
{"Имя связи", ["Имя cчитывателя", ["Событие": (Установка, Ремонт, Замена) ,"Время события"]]}
```
Чтобы определить направление перехода в связях **Метки#Турникет** и **Турникет#Метки** нужно знать позицию посетителя (метки) по отношению к зоне доступа. Соответствующий атрибут удобно держать в связи между меткой и зоной доступа, поэтому создадим соответствующую связь:
Связь **Зона\_доступа#Метки**:
```
{"Имя связи", ["Имя Метки", "Имя Посетителя", "Позиция"]}
```
Такая связь позволяет определить позицию Посетителя в любой момент времени, а также обеспечить контроль за сменой позиций при наличии нескольких зон доступа. Например, Посетитель не может попасть во внутреннее помещение, если он не вошел через турникет.
Связь **Метки#Зона\_доступа**:
```
[{"Имя связи", "Имя Зоны ", "Время входа", "Время выхода", "Время пребывания"}]
```
Такая связь позволяет получать необходимые данные для учета рабочего времени с учетом фактического времени пребывания на территории. Однако этих данных не достаточно. Во — первых, нужна информация о фирме-работодателе (фирмах-работодателях), а во-вторых — информация о графике работы. Для учета такой информации добавим новый объект Фирма в роли Работодатель и установим связи между ней и сотрудниками (Посетители).
Связь **Посетители#Фирма**:
```
[{"Имя связи", "Имя фирмы", "Время прихода на работу факт", "Время прихода на работу учет", "Время ухода с работы факт", "Время ухода с работы учет", "Время пребывания на работе факт", "Время пребывания на работе учет"}]
```
Такая связь содержит все данные необходимые для учета рабочего времени, а также разрешения возможных конфликтных ситуаций. Учетные данные строятся на основании сравнения фактических данных и графиков работы. Данные по графику работы содержаться в связи **Фирма#Посетители**:
```
{"Имя связи", ["Имя посетителя", "Посещение в нерабочие дни", "Режим работы", ["Дата", "Время прихода на работу план", "Время ухода с работы план", "Время пребывания на работе План"]]}
```
Такая связь позволяет учитывать данные по графику работы для каждого сотрудника, а также запрещать или разрешать вход в Зону доступа в нерабочие дни. Данные для связи формируются вне СКУД и должны поступать от фирм.
Теперь рассмотрим контроль за клиентами фирм. Такие посетители являются покупателями или поставщиками (или их представителями) фирм. Фирмы для них выступают не в роли Работодателя, а в роли Поставщика или Покупателя. Таким образом, у объекта появляется несколько ролей:
Соответственно изменяется и количество связей между посетителем и фирмой. И хотя теперь каждый посетитель может играть роли Сотрудника, Покупателя или Поставщика, в рамках структурной модели мы оставляем ему только одну роль — Владельца идентификатора. Зато увеличение количества связей
позволяет собирать и хранить всю информацию, необходимую для контроля за клиентами арендаторов.
Связь **Посетители#Покупатель#Фирма**:
```
[{"Имя связи", "Имя фирмы", "Время получения товара", "Время оформления документов", "Время оплаты товара"}]
```
Такая связь позволяет разрешать выход покупателя в зависимости от условий, наложенных поставщиком (все три времени не нулевые). Аналогично, в связи **Посетители#Поставщик#Фирма**:
```
[{"Имя связи", "Имя фирмы", "Время получения товара", "Время оформления документов"}]
```
содержатся данные необходимые для разрешения поставщику покинуть территорию.
Таким образом, мы построили достаточно простую структурную модель СКУД, позволяющую решать все задачи, стоящие перед такими системами, а также ряд дополнительных задач.
В дальнейшем будет изложена система управления редактированием данных и их хранение, а также приведен пример реализации с описанием использованных устройств. | https://habr.com/ru/post/283586/ | null | ru | null |
# Как завести драйвера для старых карт Mobility Radeon на Windows 8
Относительно недавно AMD выпустила специальный пакет драйверов для Windows 8, [AMD Catalyst Legacy 12.6](http://www2.ati.com/drivers/legacy/amd_catalyst_12.6_legacy_win8.exe) ([ссылка на новость на сайте AMD](http://support.amd.com/us/kbarticles/Pages/catalystlegacywin8.aspx)), но на ноутбуке с Mobility Radeon HD 3400 он не заработал (это не значит, что он обязательно не заработает у вас — проверьте его прежде, чем приступать к процедуре, описанной в этом топике).
Побывав на сайте, я обнаружил, что в секции старых мобильных карт Windows 8 не упоминается вообще. Можно завести драйвер для Windows 7. Нужен ли он вам вообще, этот драйвер от производителя, если в восьмерке есть встроенный, который довольно неплохо работает — решать вам. Но сразу скажу, Catalyst Control Center (графическая утилита для настройки) *может* не заработать, увы и ах. Как завести драйвер для Windows 7 я расскажу под катом.
1. Идем на сайт AMD и качаем последнюю версию драйвера для Windows 7 вашей архитектуры.
2. Открываем установку компонентов (windows+X -> Панель Управления -> Программы и компоненты -> Установка компонентов Windows), выбираем компонент .NET Framework 3.5 (теперь его нельзя скачать с сайта, и по умолчанию он отключен, включается именно так. Еще есть довольно неудобный способ установить его оффлайново, с установочного диска, если кому-то будет очень нужно — попробую вспомнить и напишу в комментах).
3. Пытаемся установить драйвер, скачанный с сайта AMD. Он должен установиться без ошибок (по его словам), но сразу после нажатия финального ОК мы понимаем, что на самом деле ничего не изменилось, система всё еще использует драйвер от Microsoft. Важно: хоть драйвер и не заработал, установить его (или хотя бы распаковать куда-то на жесткий диск) — необходимо!
4. Качаем и устанавливаем моддер: <http://www.hardwareheaven.com/modtool.php>
5. Если запустить сейчас моддер, то он вылетит по неизвестной причине, какие бы опции совместимости мы ему не ставили. Поэтому качаем файл по ссылке, распаковываем, и заменяем им одноименный exe-файл в том каталоге, куда был установлен моддер: <http://www.driverheaven.net/driverheaven-tools-discussion/178628-possible-fix-9-2-later.html>.
6. Ага, вот теперь уже можно запустить этот экзешник, указать ему путь до папки, куда распакованы официальные драйвера (у меня это — C:\AMD\Support\12-6-legacy\_vista\_win7\_32\_dd\_ccc\_whql), нажать кнопку modify и подождать немного.
7. Теперь идем в C:\AMD\Support\12-6-legacy\_vista\_win7\_32\_dd\_ccc\_whql\Packages\Drivers\Display\W7\_INF, или куда вы там распаковывали официальные драйвера. Видим там кучу файлов. Нас интересуют те, что заканчиваются на \*.inf, их можно устанавливать. Установка производится нажатием правой кнопки мыши на файле и выборе пункта «установить». Названия файлов в этом каталоге могут отличаться, например мой драйвер назывался CL145534.inf. Причем не все inf'ы там можно установить, в моем случае лежащий там же CW145534.inf не устанавливался. Индикатором успешной установки можно считать появление диалогового окна с надписью «успешно установлено». Если у вас драйвер не хочет устанавливаться по причине неподписанности, смотрим пункт 8, иначе пропускаем его.
8. Этот пункт нужен, если Windows откажется устанавливать драйвер по причине неподписанности. Также он наградит нас вечной надписью «Тестовый режим» в правом-нижнем углу рабочего стола (если кто-нибудь может в комментариях поведать, как убрать эту надпись, было бы шикарно)
1. Открываем командную строку в режиме повышенных привилегий (открыть новомодное метроменю пуск, напечатать на клавиатуре cmd, щелкнуть правой кнопкой на пиктограмме «Командная строка», во всплывшем внизу меню выбрать «запустить от имени администратора).
2. Набираем там следующие команды:
```
bcdedit /set {current} testsigning on
bcdedit /set {current} nointegritychecks true
```
3. Нажимаем на клавиатуре (кнопка windows) + R, вписываем туда gpedit.msc и жмякаем Enter. В открывшемся окне идем по пути Конфигурация пользователя -> Административные шаблоны -> Cистема -> Установка драйвера, в правой панели делаем двойной щелчок на элементе „Цифровая подпись драйверов устройств“, выбираем „Выключено“ и клацаем ОК
4. Перезагружаем компьютер и возвращаемся на пункт 7. (Администраторы и опытные пользователи Windows тут могут вспомнить, что есть команда gpupdate и два пробела после нее, позволяющая мгновенно обновить политики, так вот это не сработает, нужно действительно перезагрузиться)
9. Открываем свойства драйверов видеокарты. (windows+X -> Диспетчер устройств -> Видеоадаптеры -> Ваша видеокарта (ATI Mobility Radeon HD 3400 Series) -> правой кнопкой и выбрать пункт „свойства“ -> Перейти на вкладку „Драйвер“). Щелкаем кнопку „Обновить“, выбираем опцию „Выполнить поиск драйверов на этом компьютере“, выбираем опцию „Выбрать драйвер из списка уже установленных драйверов“. Там будет несколько драйверов, в том числе тот что идет из коробки вместе с Windows — у него в названии будет фигурировать строка „(Корпорация Майкрософт — WDDM v1.1)“. Нам нужен не этот, нам нужен тот, который называется как ваша карта, напирмер у меня такой: ATI Mobility Radeon HD 3400 Series. Если там ничего такого нету, возвращаемся на пункт 7 и ищем еще какой-нибудь inf, который вы забыли попробовать установить. После выбора драйвера прощелкиваем далее-далее-ОК, пока установка не завершится, а по окончании установки — перезагружаемся.
10. После перезагрузки убеждаемся, что драйвер действительно тот (открываем свойства драйверов видеокарты, как сделано в предыдущем пункте, в поле „поставщик“ название должно смениться с Microsoft на Advanced Micro Devices).
11. Проверяем, что Catalyst Control Center не работает (правой кнопкой по рабочему столу, первый пункт выпадающего меню — как раз Catalyst Control Center. После выбора этого пункта он несколько секунд думает, а потом в отдельном диалоговом окне пишет сообщение с общим смыслом „не знаю что настраивать, поэтому не запущусь). Если у вас CCC работает, обязательно отпишитесь об этом в комментах!
12. Пробуем еще раз установить: <http://www2.ati.com/drivers/legacy/amd_catalyst_12.6_legacy_win8.exe>. Если установилось — у нас должен заработать Catalyst Control Center. Если нет — ну, по крайней мере у нас есть работающий драйвер от AMD.
13. Наслаждаемся.
Надеюсь, этот пост оказался кому-то полезен, и меня не забанят за портянку на две страницы. | https://habr.com/ru/post/156339/ | null | ru | null |
# 2048 на Erlang
Наверное на неделю игры 2048 на хабре уже не успеваю, но статья не столько о игре сколько о websocket сервере на Erlang. Небольшая предыстория. Когда начал играть в 2048, то просто не мог прекратить. В ущерб работе и семье. Поэтому принял решение, что играть за меня должен бот. Но загвоздка в том, что игра клиентская, из-за чего не ведется глобальный рейтинг и не так удобно играть без браузера. Поэтому я и решил сделать серверную часть, где был бы рейтинг. И где мог бы играть мой бот без браузера.
Отмечу, что это мой первый проект на Erlang. Много программистов боится Erlang, предполагая, что это сложно. Но на самом деле это не так. Плюс, я постараюсь высветлить моменты, которые не совсем очевидны новичку в Erlang.
Для упрощения много чего захардкожено. Но я всегда рад конструктивной критике и комментариям.
Ссылка на github — [erl2048](https://github.com/peinguin/erl2048).
Ссылка на рабочий проект — [erl2048](http://2048.php.poltava.ua/). Но, думаю, под хабраэффектом проживет он недолго.
#### JavaScript
Как ни странно — начну с JS. Я не изменял оригинальные файлы, чтобы их можно было обновить с первичного репозитория, если понадобится. Я использовал:
* main.css;
* animframe\_polyfill.js для requestAnimationFrame;
* html\_actuator.js для всех анимаций
* keyboard\_input\_manager.js для событий клавиатуры, и, как показала практика, зря;
Я создал файл «main.js». Логика простая — браузер шлет на сервер события, и потом обновляет поле. Благо, animframe\_polyfill создан таким образом, что принимает сформированный grid.
Что я добавил. Инициализация соединения:
```
var websocket = new Websocket(SERVER);
websocket
.connect()
.done(function(){
var myGame = new MyGame(websocket);
});
```
На скорую руку написал обертку над «Websocket». Она очень проста, чтобы приводить здесь исходный код.
Начало новой игры:
```
self.restart = function(evt){
websocket.send(JSON.stringify({
action:'start'
}));
};
```
**Сделать ход:**
```
self.move = function(direction){
// 0: up, 1: right, 2:down, 3: left
if(!toMove){
return false;
}
if(direction === 0){
direction = 'up';
}else if(direction === 1){
direction = 'right';
}else if(direction === 2){
direction = 'down';
}else if(direction === 3){
direction = 'left';
}
websocket.send(JSON.stringify({
action:'move',
value: direction
}));
};
```
И самый большой.
**Обработка ответа сервера:**
```
self.wsHandler = function(evt){
var game = JSON.parse(evt.data);
if(game.grid){
var grid = {cells: []};
game.grid.forEach(function (column, y) {
var row = [];
column.forEach(function (cell, x) {
if(cell){
if(cell.mergedFrom){
cell.mergedFrom.forEach(function(tile){
tile['x'] = x;
tile['y'] = y;
});
}
row.push({
value: cell.value,
x: x,
y: y,
previousPosition: cell.previousPosition,
mergedFrom: cell.mergedFrom
});
}
});
grid.cells.push(row);
});
var scores = game.scores,
bestScore = 0;
if(scores && scores.length>0){
bestScore = scores[0].score;
while (scoresEl.firstChild) {
scoresEl.removeChild(scoresEl.firstChild);
}
scores.forEach(function(score){
var div = document.createElement('Div');
var name = document.createElement('Div');
var scoreEl = document.createElement('Div');
div.setAttribute("class", 'score');
name.setAttribute("class", 'name');
scoreEl.setAttribute("class", 'score');
name.appendChild(document.createTextNode(score.name));
scoreEl.appendChild(document.createTextNode(score.score));
div.appendChild(name);
div.appendChild(scoreEl);
scoresEl.appendChild(div);
});
}
actuator.actuate(grid, {
score: game.score,
bestScore: bestScore,
score: game.score,
won: game.won,
over: game.over,
keepPlaying: game.keepPlaying
});
}
//playername actuator
if(game.user){
if(playername.value !== playername){
playername.value = game.user.name;
}
}
};
```
Как видно, игра полностью зависит от сервера, потому что все расчеты происходят там. Не так как, например, в моей игре [Крестики нолики](https://github.com/peinguin/tictoe), где логика дублируется.
На самом деле, не понял, зачем в оригинале используется x и y в Tile, поэтому сервер обходится без них. А на клиенте уже дописываю, чтобы actuator сьел.
Также с сервера приходит список топ10 лучших игроков. Это нововведение моей версии. И еще игрок может изменять свой ник. Никаких регистраций и защит. Ввел имя и играй. Нужно навести на квадратик с best score чтобы увидеть общий рейтинг. Выглядит это так.
Использовать родной keyboard\_input\_manager не очень хорошо. Потому что теперь в поле ввода никнейма можно вводить не все символы. Но вы можете вставить свой ник с буфера обмена.
Плюс, я реализовал не весь функционал. Часть, что отвечает за «проигрыш» пока закрыта заглушкой, но это не очень влияет на игровой процесс. И продолжить игру после выигрыша пока нет возможности. Но выиграть еще не получилось.
#### Erlang
Эта часть будет более детально расписана. Для начала нужно установить rebar. Сделать это можно [отсюда](https://github.com/basho/rebar). Rebar может сгенерировать начальные файлы, но я их создавал вручную.
«rebar.config» — используется для автоматического скачивания и сборки зависимостей.
**Скрытый текст**
```
% The next option is required so we can use lager.
{erl_opts, [{parse_transform, lager_transform}]}.
{lib_dirs,["deps"]}.
% Our dependencies.
{deps, [
{'lager', ".*", {
git, "git://github.com/basho/lager.git", "master"}
},
{'cowboy', ".*", {
git, "git://github.com/extend/cowboy.git", "master"}
},
{'mochiweb', ".*", {
git, "git://github.com/mochi/mochiweb.git", "master"}
},
{'sqlite3', ".*", {
git, "git://github.com/alexeyr/erlang-sqlite3.git", "master"}
}
]}.
```
```
# rebar g-d
# rebar co
```
Чтобы скачать и собрать зависимости. Возможно понадобится установить «libsqlite3-dev» для sqlite драйвера.
Для запуска сервера я использую:
```
# rebar compile skip_deps=true; erl -pa ebin deps/*/ebin -eval 'starter:start().' -noshell -detached
```
После этого игра будет доступна на 8080 порту. На самом деле, научится запускать проект было самым сложным. Дальше — легче. Я создал специльный модуль «starter», который запускает все зависимости и приложение.
```
-module(starter).
-export([start/0]).
start() ->
application:start(ranch),
application:start(crypto),
application:start(cowlib),
application:start(cowboy),
application:start(inets),
application:start(mochiweb),
application:start(erl2048).
```
Теперь рассмотрю содержимое директории «src». Первое — файл «erl2048.app.src». Не знаю, на самом деле, для чего он нужен, но добавил и свой проект на всякий случай.
**Скрытый текст**
```
{application, erl2048, [
{description, "2048 game server."},
{vsn, "1"},
{modules, []},
{registered, [erl2048_sup]},
{applications, [
kernel,
stdlib,
cowboy
]},
{mod, {erl2048_app, []}},
{env, []}
]}.
```
**erl2048\_sup.erl**
```
%% Feel free to use, reuse and abuse the code in this file.
%% @private
-module(erl2048_sup).
-behaviour(supervisor).
%% API.
-export([start_link/0]).
%% supervisor.
-export([init/1]).
%% API.
-spec start_link() -> {ok, pid()}.
start_link() ->
supervisor:start_link({local, ?MODULE}, ?MODULE, []).
%% supervisor.
init([]) ->
Procs = [],
{ok, {{one_for_one, 10, 10}, Procs}}.
```
Я так понимаю, что эта штука следит, чтобы приложение не падало и перезапускает в случае надобности. Взял из примера — решил оставить.
Теперь главный файл приложения — «erl2048\_app.erl».
**Скрытый текст**
```
%% Feel free to use, reuse and abuse the code in this file.
%% @private
-module(erl2048_app).
-behaviour(application).
%% API.
-export([start/2]).
-export([stop/1]).
%% API.
start(_Type, _Args) ->
Dispatch = cowboy_router:compile([
{'_', [
{"/", cowboy_static, {file, "../client/index.html"}},
{"/websocket", ws_handler, []},
{"/static/[...]", cowboy_static, {dir, "../client/static"}}
]}
]),
{ok, _} = cowboy:start_http(http, 100, [{port, 8080}],
[{env, [{dispatch, Dispatch}]}]),
{ok, _} = db:start_link(),
erl2048_sup:start_link().
stop(_State) ->
{ok, _} = db:stop(),
ok.
```
Здесь я уже могу кое-что объяснить. Во-первых, компилируются роуты для cowboy. Потом запускается cowboy и подключение к базе данных.
В роли субд выступает sqlite. Я рассматривал еще Postgresql, mongoDB и Redis. Но остановился на sqlite, так как он самый простой. Плюс хранит данные после перезапуска. Но, думаю, создаст большую нагрузку на приложение из-за чего оно скорее ляжет. Как бы там ни было — код модуля:
**Скрытый текст**
```
-module(db).
-export([start_link/0,stop/0]).
-export([insert/2, select/0, createUser/1, changeName/2]).
start_link() ->
{ok, PID} = sqlite3:open(db, [{file, "db.sqlite3"}]),
Tables = sqlite3:list_tables(db),
case lists:member("scores", Tables) of false ->
sqlite3:create_table(db, scores, [{id, integer, [{primary_key, [asc, autoincrement]}]}, {userid, integer}, {score, integer}])
end,
case lists:member("users", Tables) of false ->
sqlite3:create_table(db, users, [{id, integer, [{primary_key, [asc, autoincrement]}]}, {name, text}])
end,
{ok, PID}.
stop() ->
sqlite3:close(db).
select() ->
Ret = sqlite3:sql_exec(db, "select users.name, scores.score from scores LEFT JOIN users ON (users.id = scores.userid) ORDER BY score desc;"),
[{columns,_},{rows,Rows}] = Ret,
formatScores(Rows).
insert(Score, Player) ->
[{columns,_},{rows,Rows}] = sqlite3:sql_exec(db, "SELECT score FROM scores WHERE userid = ?", [{1,Player}]),
DBScore = if
length(Rows) > 0 -> element(1,hd(Rows));
true -> 0
end,
if Score > DBScore ->
sqlite3:delete(db, scores, {userid, Player}),
sqlite3:write(db, scores, [{userid, Player}, {score, Score}]),
sqlite3:sql_exec(db, "DELETE FROM scores WHERE id IN (SELECT id FROM scores ORDER BY score desc LIMIT 1 OFFSET 10)");
true -> undefined
end.
formatScores([]) ->
[];
formatScores([{Name, Score} | Rows]) ->
[{struct, [{name, Name},{score, Score}]} | formatScores(Rows)].
createUser(UserName) ->
sqlite3:write(db, users, [{name, UserName}]).
changeName(Id, NewName) ->
sqlite3:update(db, users, {id, Id}, [{name, NewName}]).
```
Перейдем к модулю, который обрабатывает websocket соединения.
**ws\_handler.erl**
```
-module(ws_handler).
-behaviour(cowboy_websocket_handler).
-export([init/3]).
-export([websocket_init/3]).
-export([websocket_handle/3]).
-export([websocket_info/3]).
-export([websocket_terminate/3]).
init({tcp, http}, _Req, _Opts) ->
{upgrade, protocol, cowboy_websocket}.
websocket_init(_TransportName, Req, _Opts) ->
State = {struct, [
{ user, { struct, [{id, null},{name, <<"Player">>}] } }
]},
{ok, Req, State}.
websocket_handle({text, Msg}, Req, State) ->
Message = mochijson2:decode(Msg, [{format, proplist}]),
Action = binary_to_list(proplists:get_value(<<"action">>, Message)),
{NewState, Response} = case Action of
"start" ->
TmpState = game:init(State),
{TmpState, TmpState};
"move" ->
TmpState = game:move(list_to_atom(binary_to_list(proplists:get_value(<<"value">>, Message))), State),
{TmpState, TmpState};
"newName" ->
NewName = proplists:get_value(<<"value">>, Message),
JsonData = element(2, State),
User = proplists:get_value(user, JsonData),
{struct,UserJsonData} = User,
Id = proplists:get_value(id, UserJsonData),
db:changeName(Id, NewName),
TmpState = {struct, [
{ user, { struct, [ { name, NewName },{ id, Id } ] } }
| proplists:delete(user, JsonData)
]},
{
TmpState,
{struct, [{ user, { struct, [ { name, NewName },{ id, Id } ] } }]}
};
_Else -> State
end,
{reply, {text, mochijson2:encode(Response)}, Req, NewState};
websocket_handle(_Data, Req, State) ->
{ok, Req, State}.
websocket_info({send, Msg}, Req, State) ->
{reply, {text, Msg}, Req, State};
websocket_info(_Info, Req, State) ->
{ok, Req, State}.
websocket_terminate(_Reason, _Req, _State) ->
ok.
```
Поначалу я не понимал как оно все устроено. Оказывается, все очень просто. Есть состояние, которое задается при установке соединения. И которое передается в каждый обработчик запроса для каждого клиента свое. Основной метод здесь это «websocket\_handle». Он принимает сообщение и состояние а возвращает ответ и состояние.
Для общение используется формат JSON. В Erlang он представляется структурой типа:
```
{struct, [
{key1, Value1},
{key2, Value2},
....
]}
```
Теперь непосредственно файлы игры. Самый простой «tile.erl».
**tile.erl**
```
-module(tile).
-export([init/1, init/0, prepare/2]).
prepare(null, _) ->
null;
prepare(Tile, { X, Y }) ->
{
struct,
[
{value, proplists:get_value(value, element(2, Tile))},
{mergedFrom, null},
{previousPosition, {struct, [{ x, X - 1},{ y, Y - 1 }]}}
]
}.
init(Value) ->
{
struct,
[
{value, Value},
{mergedFrom, null},
{previousPosition, null}
]
}.
init() ->
init(2).
```
Только и умеет, что создавать новый тайл и сохранять предыдущую позицию.
«grid.erl» уже посложнее.
**grid.erl**
```
-module(grid).
-export([
build/0,
cellsAvailable/1,
randomAvailableCell/1,
insertTile/3,
availableCells/1,
cellContent/2,
removeTile/2,
moveTile/3,
size/0,
withinBounds/1,
cellAvailable/2
]).
-define(SIZE, 4).
size() ->
?SIZE.
build() ->
[[null || _ <- lists:seq(1, ?SIZE)] || _ <- lists:seq(1, ?SIZE)].
availableCells(Grid) ->
lists:append(
setY(
availableCells(Grid, 1)
)
).
availableCells([Grid | Tail ], N) when is_list(Grid) ->
[{availableCells(Grid, 1), N} | availableCells(Tail, N +1)];
availableCells([Grid | Tail ], N) ->
case Grid =:= null of
true -> [ N | availableCells(Tail, N +1)];
false -> availableCells(Tail, N +1)
end;
availableCells([], _) ->
[].
setY([{Cell, Y}|Tail]) ->
[ setY(Cell, Y) | setY(Tail)];
setY([]) ->
[].
setY([Head | Tail], Y) ->
[ {Head, Y} | setY(Tail, Y)];
setY([], _) ->
[].
cellsAvailable(Grid) ->
length(availableCells(Grid)) > 0.
randomAvailableCell(Grid) ->
Cells = availableCells(Grid),
lists:nth(random:uniform(length(Cells)) ,Cells).
insertTile({X, Y}, Tile, Grid) ->
Row = lists:nth(Y,Grid),
lists:sublist(Grid,Y - 1) ++ [ lists:sublist(Row,X - 1) ++ [Tile] ++ lists:nthtail(X,Row)] ++ lists:nthtail(Y,Grid).
cellContent({ X, Y }, Grid) ->
case withinBounds({ X, Y }) of
true -> lists:nth(X,lists:nth(Y,Grid));
false -> null
end.
removeTile({ X, Y }, Grid) ->
insertTile({X, Y}, null, Grid).
moveTile(Cell, Cell, Grid) ->
Grid;
moveTile(Cell, Next, Grid) ->
insertTile(Next, grid:cellContent(Cell, Grid), removeTile(Cell, Grid)).
withinBounds({X, Y}) when
(X > 0), (X =< ?SIZE),
(Y > 0), (Y =< ?SIZE) ->
true;
withinBounds(_) ->
false.
cellAvailable(Cell, Grid) ->
case grid:withinBounds(Cell) of
true -> cellContent(Cell, Grid) =:= null;
false -> false
end.
```
Обратите внимание на availableCells. В Erlang нужно по максимуму использовать рекурсию. Но здесь я сам себя перемудрил. Сначала сгенерировал лист, который содержал листы с одной координатой и вторую координату. А потом вносил вторую к первой. Я решил больше так не делать. Остальные функции, думаю, очевидны.
И, основной файл игры. Так и называется «game.erl».
**game.erl**
```
-module(game).
-export([init/1, move/2]).
init(State) ->
StateUser = proplists:get_value(user, element(2, State)),
StateUserJsonData = element(2, StateUser),
User = case proplists:get_value(id, StateUserJsonData) of
null ->
Name = proplists:get_value(name, StateUserJsonData),
{rowid, Id} = db:createUser(Name),
{ struct, [{name, Name},{id, Id}]};
_Else ->
StateUser
end,
{
struct,
[
{grid ,addStartTiles(grid:build())},
{user , User},
{score,0},
{scores, db:select()},
{won, false},
{over, false},
{keepPlaying, false}
]
}.
addStartTiles(Grid, 0) ->
Grid;
addStartTiles(Grid, N) ->
NewGrid = addRandomTile(Grid),
addStartTiles(NewGrid, N - 1).
addStartTiles(Grid) ->
addStartTiles(Grid, 2).
addRandomTile(Grid) ->
random:seed(now()),
case grid:cellsAvailable(Grid) of
true ->
case random:uniform(10) < 9 of
true -> Tile = tile:init();
false -> Tile = tile:init(grid:size())
end,
grid:insertTile(grid:randomAvailableCell(Grid), Tile, Grid);
false -> Grid
end.
getVector(left) ->
{ -1, 0 };
getVector(up) ->
{ 0, -1 };
getVector(right) ->
{ 1, 0 };
getVector(down) ->
{ 0, 1 }.
buildTraversals() ->
Traver = lists:seq(1, grid:size()),
{ Traver, Traver }.
buildTraversals({ 1 , _ }) ->
{ T1, T2} = buildTraversals(),
{ lists:reverse(T1), T2 };
buildTraversals({ _ , 1 }) ->
{ T1, T2} = buildTraversals(),
{ T1, lists:reverse(T2) };
buildTraversals({ _ , _ }) ->
buildTraversals().
prepareTiles( [{_Key, _Value} | _Tail ] ) ->
JsonData = [{_Key, _Value} | _Tail ],
[{ grid, prepareTiles(proplists:get_value(grid, JsonData)) } | proplists:delete(grid, JsonData) ];
prepareTiles( Grid ) ->
prepareTiles( Grid, 1).
prepareTiles([], _) ->
[];
prepareTiles([Row | Tail], Y) ->
[ prepareTileY(Row, 1, Y) | prepareTiles(Tail, Y + 1)].
prepareTileY([], _, _) ->
[];
prepareTileY([Cell | Tail], X, Y) ->
[prepareTileX(Cell, X, Y) | prepareTileY(Tail, X + 1, Y) ].
prepareTileX(Tile, X, Y) ->
tile:prepare(Tile, {X, Y}).
process_travesals_y([], _, _, JsonData) ->
JsonData;
process_travesals_y(_, [], _, JsonData) ->
JsonData;
process_travesals_y([ Y | Tail ], TraversalsX, Vector, JsonData) ->
process_travesals_y(
Tail,
TraversalsX,
Vector,
process_travesals_y( Y, TraversalsX, Vector, JsonData)
);
process_travesals_y(Y, [ X | Tail ], Vector, JsonData) ->
process_travesals_y(Y, Tail, Vector, process_travesals_y( Y, X, Vector, JsonData ));
process_travesals_y( Y, X, Vector, JsonData ) ->
moveTile({ X, Y }, Vector, JsonData).
findFarthestPosition({X, Y}, {VecX, VecY}, Grid) ->
Next = { X + VecX, Y + VecY },
case grid:cellAvailable(Next, Grid) of
true ->
findFarthestPosition(Next, {VecX, VecY}, Grid);
false ->
{
{X, Y},
Next % Used to check if a merge is required
}
end.
moveTile(Cell, Vector, JsonData) ->
Grid = proplists:get_value(grid, JsonData),
Tile = grid:cellContent(Cell, Grid),
case Tile =:= null of
true -> JsonData;
false ->
{ Farthest, Next } = findFarthestPosition(Cell, Vector, Grid),
{struct, CurrJsonData} = Tile,
CurrValue = proplists:get_value(value, CurrJsonData),
NextTile = if
Next =:= null -> null;
true ->
grid:cellContent(Next, Grid)
end,
{NextValue, NextMerged} = if
NextTile =:= null -> {null, null};
true ->
NextJsonData = element(2, NextTile),
{proplists:get_value(value, NextJsonData), proplists:get_value(mergedFrom, NextJsonData)}
end,
if CurrValue =:= NextValue,
NextMerged =:= null
->
MergedValue = CurrValue * 2,
Merged = {
struct,
[
{value, MergedValue},
{mergedFrom, [Tile,NextTile]},
{previousPosition, null}
]
},
NewGrid = grid:insertTile(Next, Merged, grid:removeTile(Cell, Grid)),
% Update the score
Score = proplists:get_value(score, JsonData) + MergedValue,
% The mighty 2048 tile
Won = if
MergedValue =:= 2048 -> true;
true -> false
end,
Removed = proplists:delete(score, proplists:delete(won, proplists:delete(grid, JsonData))),
[
{grid,NewGrid},
{won,Won},
{score,Score} |
Removed
];
true ->
[
{
grid,
grid:moveTile(Cell, Farthest, proplists:get_value(grid, JsonData))
}
| proplists:delete(grid, JsonData)
]
end
end.
move(left, State) ->
move(getVector(left), State);
move(right, State) ->
move(getVector(right), State);
move(up, State) ->
move(getVector(up), State);
move(down, State) ->
move(getVector(down), State);
move(Vector, State) ->
{struct, JsonData} = State,
case
proplists:get_value(over, JsonData) or (
proplists:get_value(won, JsonData) and (not proplists:get_value(keepPlaying, JsonData))
)
of
true -> State;
_Else ->
PreparedJsonData = updateBestScore(prepareTiles(JsonData)),
{ TraversalsX, TraversalsY } = buildTraversals(Vector),
NewJsonData = process_travesals_y(
TraversalsY,
TraversalsX,
Vector,
PreparedJsonData
),
NewGrid = proplists:get_value(grid, NewJsonData),
Grid = proplists:get_value(grid, PreparedJsonData),
if
NewGrid =/= Grid -> %If changed - add new tile
{struct, UserJsonData} = proplists:get_value(user, NewJsonData),
NewScore = proplists:get_value(score, NewJsonData),
Score = proplists:get_value(score, PreparedJsonData),
case NewScore > Score of true ->
db:insert(
proplists:get_value(score, NewJsonData),
proplists:get_value(id, UserJsonData)
);
_Else -> undefined
end,
Over = case movesAvailable(NewGrid) of
true -> false;
fale -> true % Game over!
end,
Removed = proplists:delete(grid, proplists:delete(over, NewJsonData)),
{struct,[{ grid, addRandomTile(NewGrid) }, { over, Over } | Removed ]};
true -> %return state otherwise
{struct,PreparedJsonData}
end
end.
movesAvailable(_) ->
true.
updateBestScore(JsonData) ->
[{ scores, db:select() } | proplists:delete(scores, JsonData) ].
```
Функция init — создает нового пользователя, если тот не был создан. Или берет из предыдущей игры.
```
init(State) ->
StateUser = proplists:get_value(user, element(2, State)),
StateUserJsonData = element(2, StateUser),
User = case proplists:get_value(id, StateUserJsonData) of
null ->
Name = proplists:get_value(name, StateUserJsonData),
{rowid, Id} = db:createUser(Name),
{ struct, [{name, Name},{id, Id}]};
_Else ->
StateUser
end,
{
struct,
[
{grid ,addStartTiles(grid:build())},
{user , User},
{score,0},
{scores, db:select()},
{won, false},
{over, false},
{keepPlaying, false}
]
}.
```
Основная функция — move. Отвечает за пересчет игрового поля. Здесь были трудности, в основном из-за недостатка опыта функционального программирования.
```
move(left, State) ->
move(getVector(left), State);
move(right, State) ->
move(getVector(right), State);
move(up, State) ->
move(getVector(up), State);
move(down, State) ->
move(getVector(down), State);
move(Vector, State) ->
{struct, JsonData} = State,
case
proplists:get_value(over, JsonData) or (
proplists:get_value(won, JsonData) and (not proplists:get_value(keepPlaying, JsonData))
)
of
true -> State;
_Else ->
PreparedJsonData = updateBestScore(prepareTiles(JsonData)),
{ TraversalsX, TraversalsY } = buildTraversals(Vector),
NewJsonData = process_travesals_y(
TraversalsY,
TraversalsX,
Vector,
PreparedJsonData
),
NewGrid = proplists:get_value(grid, NewJsonData),
Grid = proplists:get_value(grid, PreparedJsonData),
if
NewGrid =/= Grid -> %If changed - add new tile
{struct, UserJsonData} = proplists:get_value(user, NewJsonData),
NewScore = proplists:get_value(score, NewJsonData),
Score = proplists:get_value(score, PreparedJsonData),
case NewScore > Score of true ->
db:insert(
proplists:get_value(score, NewJsonData),
proplists:get_value(id, UserJsonData)
);
_Else -> undefined
end,
Over = case movesAvailable(NewGrid) of
true -> false;
fale -> true % Game over!
end,
Removed = proplists:delete(grid, proplists:delete(over, NewJsonData)),
{struct,[{ grid, addRandomTile(NewGrid) }, { over, Over } | Removed ]};
true -> %return state otherwise
{struct,PreparedJsonData}
end
end.
```
Например, чтобы узнать, совершился ли ход, я сравниваю старое состояние и новое. Не используется внешняя переменная как в JS варианте. Не знаю, уменьшит ли это производительность. И потом проверяю изменился ли счет, чтобы не делать лишних запросов к БД.
Вообще, при функциональном подходе, редко когда требуется передавать много параметров в функцию. Здесь наибольше меня смущает то, что я передаю TraversalsY, TraversalsX, Vector в process\_travesals\_y, хотя TraversalsY и TraversalsX и так зависят от Vector. Но решил пока оставить так.
Чтобы не повторять опыт «availableCells» функцию «process\_travesals\_y» я расписал больше, но теперь она отдельно идет по X и отдельно по Y. И в итоге для каждого ненулевого элемента игрового поля вызывает «moveTile». Которая, в принципе, практически полностью соответствует JS-оригиналу.
```
moveTile(Cell, Vector, JsonData) ->
Grid = proplists:get_value(grid, JsonData),
Tile = grid:cellContent(Cell, Grid),
case Tile =:= null of
true -> JsonData;
false ->
{ Farthest, Next } = findFarthestPosition(Cell, Vector, Grid),
{struct, CurrJsonData} = Tile,
CurrValue = proplists:get_value(value, CurrJsonData),
NextTile = if
Next =:= null -> null;
true ->
grid:cellContent(Next, Grid)
end,
{NextValue, NextMerged} = if
NextTile =:= null -> {null, null};
true ->
NextJsonData = element(2, NextTile),
{proplists:get_value(value, NextJsonData), proplists:get_value(mergedFrom, NextJsonData)}
end,
if CurrValue =:= NextValue,
NextMerged =:= null
->
MergedValue = CurrValue * 2,
Merged = {
struct,
[
{value, MergedValue},
{mergedFrom, [Tile,NextTile]},
{previousPosition, null}
]
},
NewGrid = grid:insertTile(Next, Merged, grid:removeTile(Cell, Grid)),
% Update the score
Score = proplists:get_value(score, JsonData) + MergedValue,
% The mighty 2048 tile
Won = if
MergedValue =:= 2048 -> true;
true -> false
end,
Removed = proplists:delete(score, proplists:delete(won, proplists:delete(grid, JsonData))),
[
{grid,NewGrid},
{won,Won},
{score,Score} |
Removed
];
true ->
[
{
grid,
grid:moveTile(Cell, Farthest, proplists:get_value(grid, JsonData))
}
| proplists:delete(grid, JsonData)
]
end
end.
```
На этом, думаю, рассказ об обработке websocket запросов посредством Erlang закончен. С удовольствием отвечу на все вопросы. | https://habr.com/ru/post/216517/ | null | ru | null |
# Разработка Tic-Tac-Toe на нативном JavaScript
Всем привет, и доброго времени суток, Хабравчане! Будучи в отпуске, дабы отвлечься от рутинных и рабочих процессов, решил чем-нибудь развлечь себя, и написать что-нибудь эдакое.
На чём писать? Решил выбрать нативный JavaScript, дабы подтянуть свой скилл, в одном из самых неоднозначных языков программирования. Что писать? Хоть и занимаюсь веб-разработкой, но давно испытываю любовь к GameDev'у, человек я творческий, что поделаешь. Поэтому остановился на одной из самых простых игр, — крестики-нолики.
Я не включал секундомер садясь за сие творчество, но вспоминая процесс, думаю, что потратил на игру часов 15-20. Особо за временем не следил, поэтому могу ошибаться. В день тратил по часу-два, не больше. Старался получать максимум удовольствия от процесса.
Чистый JavaScript, и только хардкор! Не использовал никаких библиотек, и не заглядывал в другие реализации сей игры, дабы не путать собственное виденье. Поэтому заранее извиняюсь, местами решения могут быть далеки от идеалов, но я готов к диалогу, к критике, или просто к советам.
Вся игра держится на трёх файлах JS, на одном стилевом файле, и на index.html. Плюс директория с трёмя изображениями (крестик, нолик, фон). Дизайнер с меня околонулевой, поэтому за оформление прошу сильно не пинать.
Итак, три файла JS, сердце игры, — main.js, ai.js и helpers.js. С Вашего позволения, я расскажу только про два, т.к. в helpers.js ничего особо интересного, там описаны вспомогательные и тривиальные функции. Вы можете сами его посмотреть, к их критике я тоже готов.
Ещё одно примечание, я не задавался целью кроссбраузерности, всё проверялась мною на последнем Chrome. Также используются некоторые возможности ES6, поэтому с недружелюбными к нему браузерами могут возникнуть проблемы.
Весь js-код в трёх файлах уместился в 272 строчки (на момент написания сей статьи). Файл main.js содержит основной код, а в файле ai.js хранится реализация подобия ИИ (язык не поворачивается назвать его просто ИИ, поэтому позвольте дальше я буду именовать его ПИИ).
Приступим к разбору.
Небольшой экскурс по переменным. Единственное, что я рассмотрю из helpers.js:
```
// Sides player and AI
var player;
var ai;
// Who goes first
var first_run;
// Battle blocks in the game
var blocks = document.getElementsByClassName("block");
// Collections win lines for points
var win_lines = [
["1","2","3"],
["4","5","6"],
["7","8","9"],
["1","4","7"],
["2","5","8"],
["3","6","9"],
["1","5","9"],
["3","5","7"],
];
```
Прошу прощения за свой ломанный английский в комментариях к коду. Переменные player и ai определяют, каким знаком играют игрок и ПИИ, у кого крестик, а у кого нолик. Переменная first\_run определяет кто ходит первым. Переменная blocks содержит массив html-элементов, т.н. клетки на игровом поле. Ну и переменная win\_lines — двумерный массив победных линий, сбор одной из которых и составляет цель игры.
Начало main.js:
```
Array.from(blocks).forEach((element) => {
element.addEventListener("click", function() {
if (element.classList.contains(player) || element.classList.contains(ai)) {
return;
}
var ai_count = countPoints(ai);
var player_count = countPoints(player);
if (first_run == "player" && ai_count < player_count) {
return;
}
if (first_run == "ai" && ai_count == player_count) {
return;
}
setImg(this, player);
var win = identifyWinner(player);
if (win) {
endPlay("win");
window.clearInterval(monitoringSteps);
}
});
});
```
Договоримся, знаками я буду называть крестики или нолики.
Перебираем массив элементов и вешаем на каждую клетку игрового поля слушателя на клик. По клику на клетку, если в ней нет знака, ставим знак игрока. На строках 9-10 подсчитываем все знаки и игрока и ПИИ. Строки с 12 по 17 помогают нам контролировать чей первый ход и очерёдность ходов. Чтобы игрок не мог походить не в свою очередь. На 19 строчке функция ставящая знак игрока в клетку по которой он щёлкнул, эта процедура описана в helpers.js ничего интересного. В конце определяем победный ли ход сделал игрок, если да, игра окончена. Функции indentifyWinner и endPlay описаны там же, в helpers.
```
var originally_points_player = 0;
var monitoringSteps = setInterval(() => {
var player_points_count = countPoints(player);
if (player_points_count > originally_points_player) {
originally_points_player = player_points_count;
var empty_blocks = emptyBlocks();
if (empty_blocks.length > 0) {
// run enemy
var favorite_run = selectFavoriteRun(empty_blocks);
if (favorite_run > 0) {
var block_for_run = document.getElementById(favorite_run);
} else {
var random_index = Math.floor( Math.random() * (empty_blocks.length) );
var block_for_run = empty_blocks[random_index];
}
setImg(block_for_run, ai);
// end run enemy
var win = identifyWinner(ai);
if (win) {
endPlay("lose");
}
}
}
}, 2000);
```
Код отслеживающий ход игрока и передающий инициативу ПИИ. Строка 1, переменная originally\_points\_player хранит изначальное количество знаков игрока. Изначальное — имеется ввиду, до его последнего хода. На 4ой строчке подсчитываем знаки игрока, 6 строчка, если их количество увеличилось, значит игрок сделал ход. Передаём инициативу ПИИ. Выбираем пустые блоки (клетки на игровом поле) и если они имеются, даём право хода ПИИ. Функция selectFavoriteRun(), в которую мы передаём пустые клетки, описана в ai.js, её мы рассмотрим позже. А пока скажу, что суть её в определении наиболее выгодного хода для ПИИ. Функция возвращает или ноль, если выгодный ход неопределён, либо ID-номер клетки, в которую надо ставить знак ПИИ. Если возвращённое значение больше нуля, выбираем блок-клетку для хода, если меньше, выбираем случайный блок-клетку из пустых.
И на строчке 21 ставим знак ПИИ на игровое поле. С 24 по 27 строку определяем победный ли ход сделал ПИИ.
```
setInterval(() => {
var done = document.getElementById("inscription").innerHTML.length == 0;
if (emptyBlocks().length == 0 && done) {
endPlay("draw");
}
}, 1000);
// Code for select side in the game
var wrapper_button_select = document.getElementById("wrapper-button");
var button_select = wrapper_button_select.getElementsByTagName("button")[0];
button_select.addEventListener("click", function() {
selectSide();
// Who goes first
if (player == "cross") {
first_run = "player";
} else if (player == "zero") {
first_ai();
first_run = "ai";
}
});
// Button "Again?"
var button_again = document.getElementById("info-again");
button_again.addEventListener("click", function() {
location.reload();
});
```
Далее в main.js менее интересные вещи. Здесь сначала отслеживаем ситуацию ничьей. Если клетки закончились и победитель не был определён, то ничья. Переменная done для того, чтобы определение ничьей не происходило до начала или после окончания игры.
Дальше, код для выбора стороны игроком и код для кнопочки «Again?».
Переходим в ai.js, наверное к самому интересному. Пока он скуден и состоит лишь из 44 строчек. Но мысли и идеи для него есть, отпуск закончился и всё упирается во время…
```
var selectFavoriteRun = (empty_blocks) => {
var points_player = document.getElementsByClassName(player);
var ids_player = getIdsArray(points_player);
// Do not to give player win
var favor_run_no_win_player = determiningPlaceForRun(ids_player);
var points_ai = document.getElementsByClassName(ai);
var ids_ai = getIdsArray(points_ai);
// Run for win AI
var favor_run_win_ai = determiningPlaceForRun(ids_ai);
return (favor_run_win_ai > 0) ? favor_run_win_ai : favor_run_no_win_player;
};
```
Ранее виданная функция selectFavoriteRun. Пока определение выгодного хода для ПИИ, основывается на двух принципах. Первый это, если есть ход который позволит ПИИ выиграть, ну так делаем его. Если такого нет. Тогда вступает в силу второй принцип, если есть опасность, что следующим ходом игрок выиграет, всеми силами пытаемся не дать ему это сделать. Если и такой ситуации не предвидится, возвращаем ноль. И пусть рандом решает куда ходить.
Итак, 3-4 строки, мы определяем все знаки игрока на поле. Берём айдишники этих клеток и передаём в ещё одну функцию determiningPlaceForRun, которую рассмотрим ниже. Получаем из функции либо айдишник выгодной для хода клетки, либо ноль.
В строках с 8 по 11, мы делаем тоже самое со знаками ПИИ, для определения возможно победного хода. Ну и возвращаем результат. Если есть вариант для победы, возвращаем его, нет, тогда возвращаем ход для не допуска победы игрока.
```
var determiningPlaceForRun = (array_elements_points) => {
var favorite_run = 0;
win_lines.forEach((positions) => {
var points_in_row = 0;
var point_for_win = 0;
for (var i = 0; i < array_elements_points.length; i++) {
if (positions.indexOf(array_elements_points[i]) != -1) {
points_in_row++;
}
if (points_in_row == 2) {
point_for_win = positions.diff(array_elements_points)[0];
var is_cross = document.getElementById(point_for_win).classList.contains(player);
var is_zero = document.getElementById(point_for_win).classList.contains(ai);
if (is_zero || is_cross) {
point_for_win = 0;
}
}
}
if (point_for_win > 0) {
favorite_run = point_for_win;
}
});
return favorite_run;
};
```
Ну и самая ужасная функция — определения клетки для хода.Принцип одинаков и для поиска варианта победы, и для не допущения победы игрока. В цикле проходим по списку победных линий. Закладываем две переменные points\_in\_row, point\_for\_win. Первая для подсчёта однотипных знаков в линиях победы, вторая для потенциально выгодного хода.
После запускаем вложенный for, который перебирает все, уже стоящие знаки на поле. Условие на 8 строке проверяет есть ли знак в победной линии. Если таких знаков набирается два. Значит есть возможность выиграть, или проиграть (в зависимости чьи знаки проверяем). На 12 строчке присваиваем оставшуюся клетку из победной линии, переменной для выгодного хода. С 13 по 17 строчку перестраховываемся проверяем свободна ли клетка. Если нет аннулируем выгодный ход. (На самом деле из-за не оптимальности логики, без этой проверки вообще никак. Поскольку мы проверяем наличие только одного вида знаков в клетках, в тоже время «типа-свободно-выгодная» клетка возможно уже занята знаком другого типа).
В конце если выгодный ход больше нуля он вернётся, иначе из функции вылетит ноль.
Вот таков пока мой примитивный Тиктактой. В будущем есть планы, углубится в ES6 и заюзать его в полную мощь. Доработать ai.js чтобы ПИИ не пользовался рандомом при ходе, а сразу стремился выиграть. А также реализация уровней сложности игры. Но всё упирается во время. Всем спасибо за внимание и добра!
[Ссылка на GitHub проекта.](https://github.com/Ivnkara/tictactoe) | https://habr.com/ru/post/347670/ | null | ru | null |
# Как написать игру для компьютера, в котором нет устройств ввода и вывода
Что можно сделать с [компьютером на электромагнитных реле](https://habr.com/post/331208/) у которого нет никаких устройств ввода, а из устройств вывода — только дамп восьми регистров?
Поиграть в игры, конечно! Играли же [древние люди](https://habr.com/post/125484/) на калькуляторах МК-61/52, которые лишь немногим нагляднее.
Угадай число
------------
Начал я с игры, где компьютер с помощью половинного деления должен найти загаданное игроком целое число от 0 до 100.
Свою догадку компьютер записывает в регистр A, а затем останавливается.
Значения всех регистров можно увидеть благодаря светодиодам, встроенным в реле:
Теперь игрок должен изменить код программы в ПЗУ, заменив константу, загружаемую в регистр D. Если там не 0, это значит, что предположение больше загаданного числа. Иначе — меньше. После этого нужно нажать кнопку «продолжить работу». Проверив регистр D, компьютер использует прежнее предположение как верхний или нижний предел в следующей попытке.
**Первая версия программы**
```
MOVI B, 1 ; 00: 10000001 00000001
MOVI C, 101 ; 01: 10000010 01100101
Loop:
ADD A, B, C ; 02: 01001000 00011010
SHR A, A ; 03: 01111000 00001100
HALT ; 04: 00010000 00000000
MOVI D, guess ; 05: 10000011 iiiiiiii
OR F, D, D ; 06: 01101000 00110011
JMP NZ, Greater ; 07: 11100111 00001010
MOV B, A ; 08: 00011001 00000000
JMP Loop ; 09: 10000111 00000010
Greater:
MOV C, A ; 0a: 00011010 00000000
JMP Loop ; 0b: 10000111 00000010
```
Недостаток первой программы в том, что ей неудобно пользоваться. Это можно понять, посмотрев на фотографию ПЗУ — не очень-то легко переключать такие маленькие тумблеры, играя в игру (а ведь при этом надо ещё и следить, чтобы программу случайно не испортить).
Поэтому я придумал другой вариант ввода. Для отладки рядом с каждым регистром [предусмотрен тумблер](https://habr.com/post/258337/) для сброса его значения. Его переключать намного удобнее, чем менять ПЗУ.
Теперь компьютер заранее заносит единицу в регистр D, а игрок либо сбрасывает его (если догадка меньше, чем задуманное число), либо оставляет как есть (если догадка больше).
**Финальная версия программы**
```
MOVI B, 1 ; 00: 10000001 00000001
MOVI C, 101 ; 01: 10000010 01100101
Loop:
ADD A, B, C ; 02: 01001000 00011010
SHR A, A ; 03: 01111000 00001100
MOVI D, 1 ; 04: 10000011 00000001
HALT ; 05: 00010000 00000000
OR F, D, D ; 06: 01101000 00110011
JMP NZ, Greater ; 07: 11100111 00001010
MOV B, A ; 08: 00011001 00000000
JMP Loop ; 09: 10000111 00000010
Greater:
MOV C, A ; 0a: 00011010 00000000
JMP Loop ; 0b: 10000111 00000010
```
Игра вычитания (игра Баше)
--------------------------
Другая классическая игра, которую часто реализуют начинающие программисты — игра Баше.
В ней два игрока из кучки, содержащей первоначально N предметов, по очереди берут не менее одного и не более М предметов. Проигравшим считается тот, кому нечего брать.
В моём варианте игра идёт с компьютером. Изначально в кучке 21 предмет (например, 21 спичка). Игроки берут от 1 до 3 спичек в свой ход, а выигрывает тот, кто берёт последнюю спичку.
В игре есть выигрышная стратегия для первого игрока — всегда оставлять число спичек, которое кратно четырём. Так как 0 тоже кратно четырём, то второй игрок привести игру в эту позицию не сможет, а значит проиграет.
Компьютер ходит вторым, оставляя шанс человекам, но ошибок он не делает. И если игрок не будет следовать выигрышной стратегии, то это сделает компьютер.
**Первая версия программы**
```
MOVI A, 21 ; 00: 10000000 00001101
Loop:
HALT ; 01: 00010000 00000000
MOVI B, move ; 02: 10000001 000000mm
SUB A, A, B ; 03: 01011000 00001001
AND C, A, 3 ; 04: 01100010 10001011
MOVI Z, C, 1 ; 05: 10010010 00000001
SUB A, A, C ; 06: 01011000 00001010
JMP Loop ; 07: 10000111 00000001
```
В первой версии использовался тот же подход, что и для «угадай число» — в свой ход нужно было закодировать число спичек внутри одной из инструкций. Даже можно было считерить и взять все спички сразу, а компьютер ничего не заметит.
Но потом я переписал и эту программу тоже. Теперь в три регистра (B, C, D) компьютер заносит по 1, а игрок должен сбросить 0, 1 или 2 из них. Оставшиеся единицы — это те спички, которые он берёт. Читерить тоже можно, если сбросить все три регистра (как будто не берёшь ничего).
**Финальная версия программы**
```
MOVI A, 21 ; 00: 10000000 00010101
Loop:
MOVI B, 1 ; 01: 10000001 00000001
MOVI C, 1 ; 02: 10000010 00000001
MOVI D, 1 ; 03: 10000011 00000001
HALT ; 04: 00010000 00000000
SUB A, A, B ; 05: 01011000 00001001
SUB A, A, C ; 06: 01011000 00001010
SUB A, A, D ; 07: 01011000 00001011
AND C, A, 3 ; 08: 01100010 10001011
MOVI Z, C, 1 ; 09: 10010010 00000001
SUB A, A, C ; 0a: 01011000 00001010
JC Exit ; 0b: 10110111 00001101
JNZ Loop ; 0c: 11100111 00000001
Exit:
HALT ; 0d: 00010000 00000000
```
Конечно программа получилось несколько длиннее, но зато пользоваться ей значительно удобнее.
Дальше я планирую допаять ПЗУ (сейчас есть только 32 слова из возможных 64), а также добавить-таки устройство ввода в виде матрицы из тумблеров. Может тогда получится сделать хотя бы крестики-нолики. | https://habr.com/ru/post/421491/ | null | ru | null |
# Система BBR: регулирование заторов непосредственно по заторам
### Измерение пропускной способности узких мест по времени двойного прохода пакета
По всем параметрам, сегодняшний интернет не может перемещать данные так быстро, как должен. Большинство пользователей сотовой связи в мире испытывают задержки от нескольких секунд до нескольких минут: публичные точки WiFi в аэропортах и на конференциях ещё хуже. Физикам и климатологам нужно обмениваться петабайтами данных с коллегами по всему миру, но они сталкиваются с тем, что их тщательно продуманная многогигабитная инфраструктура часто выдаёт всего несколько мегабит в секунду на трансконтинентальных линиях. [6]
Эти проблемы возникли из-за выбора архитектуры, который был сделан при создании системы регулирования заторов TCP в 80-е годы — тогда потерю пакетов решили интерпретировать как «затор». [13] Эквивалентность этих понятий была справедливой для того времени, но только из-за ограничений технологии, а не по определению. Когда NIC (контроллеры сетевых интерфейсов) модернизировали с мегабитных до гигабитных скоростей, а микросхемы памяти — с килобайт до гигабайт, до связь между потерей пакетов и заторами стала менее очевидной.
В современном TCP регулирование заторов по потере пакетов — даже в наиболее совершенной технологии такого рода CUBIC [11] — основная причина этих проблем. Если буферы узких мест слишком большие, то система регулирования заторов по потере пакетов держит их полными, вызывая излишнюю сетевую буферизацию. Если буферы слишком маленькие, то система регулирования заторов по потере пакетов неверно интерпретирует потерю пакета как сигнал затора, что ведёт к снижению пропускной способности. Решение этих проблем требует альтернативы регулированию заторов по потере пакетов. Для нахождения этой альтернативы следует разобраться, где и как возникают заторы.
Затор и узкое место
===================
В любой момент времени в (полнодуплексное) соединении TCP есть только одно самое медленное звено или *узкое место* в каждом направлении. Узкое место важно по следующим причинам:
* Оно определяет максимальную скорость передачи данных по соединению. Это главное свойство несжатого потока данных (например, представьте шестиполосное шоссе в час пик, если из-за ДТП один небольшой отрезок дороги ограничен всего одной полосой. Трафик перед местом ДТП будет двигаться не быстрее, чем трафик через эту полосу.
* Это то место, где постоянно образуются очереди. Они уменьшаются только в том случае, если интенсивность исходящего потока из «бутылочного горлышка» превысит интенсивность входящего потока. Для соединений, работающих на максимальной скорости передачи все исходящие потоки к узкому месту всегда имеют более высокую интенсивность исходящего потока, так что очереди перемещаются к «бутылочному горлышку».
Независимо от того, сколько линков в соединении и какие у них скорости по отдельности, с точки зрения TCP сколь угодно сложный маршрут представляется как единое соединение с одинаковым RTT (время двойного прохода пакета, то есть время прохождения в оба конца) и пропускной способностью узкого места. Два физических ограничения, *RTprop* (round-trip propagation time, время двойного прохода пакета) и *BtlBw* (bottleneck bandwidth, пропускная способность узкого места), влияют на производительность передачи. (Если бы сетевой путь был материальной трубой, RTprop был бы длиной трубы, а BtlBw — её диаметром).
На иллюстрации 1 показаны разнообразные сочетания RTT и скорости передачи с объёмом данных *в полёте*, то есть inflight (данные отправлены, но без подтверждения доставки). Синие линии показывают ограничение RTprop, зелёные линии — ограничение BtlBw, а красные линии — буфер узкого места. Операции в серых областях невозможны, поскольку противоречат хотя бы одному ограничению. Переходы между ограничениями привели к образованию трёх районов (app-limited, bandwidth-limited и buffer-limited) с качественно разным поведением.
*Рисунок 1*
Когда в полёте недостаточно данных, чтобы заполнить трубу, RTprop определяет поведение; в противном случае доминирует BtlBw. Линии ограничения пересекаются в точке , она же BDP трубы (bandwidth-delay product, производное пропускной способности и задержки). Поскольку труба полная после этой точки, то излишек  создаёт очередь к узкому месту, что приводит к линейной зависимости RTT от данных inflight, показанной на верхнем графике. Пакеты отбрасываются, когда излишек превышает вместимость буфера. *Затор* — это просто непрерывное нахождение справа от линии BDP, а *регулирование заторов* — некая схема для установления ограничения, как далеко справа от линии BDP, в среднем, происходит передача данных.
Регулирование заторов по потерям работает на правой границе района, ограниченного пропускной способностью канала (bandwidth-limited), обеспечивая полную пропускную способность узкого места за счёт больших задержек и частой потери пакетов. В те времена, когда память была дорога, размеры буфера лишь немного превышали BDP, что минимизировало избыточную задержку регулирования заторов по потерям. Последующие снижения цен на память привели к увеличению излишней сетевой буферизации и росту RTT до секунд вместо миллисекунд. [9]
На левом краю района, ограниченного пропускной способностью канала, есть рабочая точка с лучшими условиями, чем справа. В 1979 году Леонард Клейнрок [16] показал, что данная рабочая точка оптимальна, она максимизирует фактическую пропускную способность с минимизацией задержек и потерь, как для отдельных соединений, так и для сети в целом [8]. К сожалению, примерно в то же время Джеффри Яффе доказал, что невозможно создать распределённый алгоритм, который сходится в этой рабочей точке. Этот вывод изменил направление исследований. Вместо поиска распределённого алгоритма, который стремится к оптимальной рабочей точки Клейнрока, исследователи начали изучать альтернативные подходы к регулированию заторов.
Наша группа в компании Google каждый день тратит часы на изучение логов с перехватами заголовков пакетов TCP со всего мира, осмысляя аномалии и патологии поведения. Обычно мы первым делом ищем ключевые характеристики маршрута, RTprop и BtlBw. То, что их можно вывести из сетевых трейсов, позволяет предположить, что вывод Яффе мог быть не таким однозначным, как когда-то казалось. Его вывод полагается на фундаментальную неопределённость измерения (например, будь измеренное увеличение RTT вызвано изменением длины пути, уменьшением пропускной способности узкого места или увеличением задержки в очереди из-за трафика от другого соединения). Хотя невозможно устранить неопределённость каждого конкретного измерения, но поведение соединения во времени даёт более ясную картину, подсказывая возможность применения стратегий измерений, созданных для устранения неопределённости.
Совместив эти измерения с надёжным следящим контуром, применив последние достижения в системах управления [12], можно надеяться на разработку распределённого протокола регулирования заторов, который реагирует на действительный затор, а не на потерю пакетов или кратковременную задержку в очереди. И он будет с высокой вероятностью сходиться в оптимальной рабочей точке Клейнрока. Так начался наш трёхлетний проект по разработке системы управления заторами на основе измерения двух параметров, которые характеризуют маршрут: пропускной способности узкого места и времени двойного прохода пакета, или BBR.
Характеристика узкого места
===========================
Соединение работает с максимальной пропускной способностью и минимальной задержкой, когда (баланс скорости) скорость прибытия пакетов к узкому месту равняется BtlBw и (полный канал) общее количество данных в полёте равняется BDP ().
Первое условие гарантирует, что узкое место используется на 100%. Второе гарантирует, что у нас достаточно данных, чтобы предотвратить простой узкого места, но не переполнить канал. Условие баланса скорости само по себе *не* гарантирует отсутствия очереди, только её неизменный размер (например, если соединение начинается с отправки 10-пакетного Initial Window в пятипакетный BDP, затем работает в точности на одинаковой скорости узкого места, то пять из десяти начальных пакетов заполнят канал, а излишек сформирует стоячую очередь в узком месте, которая не сможет рассосаться). Точно так же, условие полного канала не гарантирует отсутствия очереди (например, соединение отправляет BDP всплесками по BDP/2 и полностью использует узкое место, но но средняя очередь составляет BDP/4). Единственный способ минимизировать очередь в узком месте и по всему каналу — это соответствовать обоим условиям одновременно.
Значения BtlBw и RTprop изменяются в течение срока жизни соединения, так что их следует постоянно оценивать. В настоящее время TCP отслеживает RTT (интервал времени между отправкой пакета данных до сообщения о его доставке), потому что это требуется для определения потерь. В любой момент времени ,
где  представляет собой «шум» от очередей вдоль маршрута, стратегию получателя с задержкой подтверждений, скопление подтверждений и т.д. RTprop — это физическая характеристика соединения, и она изменяется только при изменении самого канала. Поскольку изменения канала происходят во временном масштабе *≥* *RTprop*, то беспристрастной и эффективной оценкой времени  будет
![$\widehat{RTprop} = RTprop +min(\eta_t) = min (RTT_t)\;\;\;\;\forall t \in [T - W_R, T]$](https://habrastorage.org/getpro/habr/post_images/4fd/1dc/212/4fd1dc212a231b684b4e714271213af4.svg)
то есть запуск  во временном окне  (которое обычно составляет от десятков секунд до минут).
В отличие от RTT, ничто в спецификациях TCP не требует реализации для отслеживания пропускной способности узкого места, но хорошую оценку этого можно получить из отслеживания скорости доставки. Когда подтверждение о доставке какого-то пакета возвращается к отправителю, оно показывает RTT пакета и анонсирует доставку данных в полёте, когда пакет отбывает. Средняя скорость доставки между отправкой пакета и получением подтверждения — это отношение доставленных данных к прошедшему времени: . Эта скорость должна быть меньше или равна пропускной способности узкого места (количество по прибытию точно известно, так что вся неопределённость заключается в , которая должна быть больше или равна настоящему интервалу прибытия; поэтому отношение должно быть меньше или равно настоящей скорости доставки, которое, в свою очередь, ограничено сверху ёмкостью узкого места). Следовательно, максимальное окно скорости доставки — это эффективная, беспристранстная оценка BtlBw:
![$\widehat{BtlBw} = max(deliveryRate_t)\;\;\;\;\forall t \in [T - W_B, T]$](https://habrastorage.org/getpro/habr/post_images/aab/77f/87b/aab77f87b3f3fafbfa304d0bdc63e2d1.svg)
где окно времени  обычно составляет от шести до десяти RTT.
TCP должен записать время отправки каждого пакета, чтобы вычислить RTT. BBR дополняет эти записи общим количеством доставленных данных, так что прибытие каждого подтверждения сообщает одновременно и RTT, и результат измерения скорости доставки, которую фильтры преобразуют в оценки RTprop и BtlBw.
Заметьте, что эти значения полностью независимы: RTprop может изменяться (например, при изменении маршрута), но обладает тем же узким местом, или BtlBw может изменяться (например, когда меняется пропускная способность беспроводного канала) без изменения маршрута. (Независимость обеих сдерживающих факторов — там причина, почему они должны быть известны, чтобы связать поведение при отправке с маршрутом доставки). Поскольку RTprop виден только с левой стороны BDP, а BtlBw — только с правой стороны на рисунке 1, то они подчиняются принципу неопределённости: всякий раз, когда одно из двух можно измерить, второе измерить невозможно. Интуитивно это можно понять следующим образом: чтобы определить ёмкость канала, его нужно переполнить, что создаёт очередь, которая не даёт возможность измерить длину канала. Например, приложение с протоколом запросов/ответов может никогда не отправить достаточно данных для заполнения канала и наблюдения BtlBw. Многочасовая передача большого массива данных может всё своё время потратить в районе с ограниченной пропускной способностью и получить только единственный образец RTprop от RTT у первого пакета. Присущий принцип неопределённости означает, что вдобавок к оценкам для восстановления двух параметров маршрута, должны быть такие состояния, которые отслеживают одновременно и что можно узнать в текущей рабочей точке и, по мере того как информация теряет свежесть, как перейти в рабочую точку, где можно получить более свежие данные.
Сопоставление потока пакетов с путём доставки
=============================================
Основной алгоритм BBR состоит из двух частей:
**Когда получаем подтверждение (ack)**
Каждое подтверждение предоставляет новый RTT и измерения средней скорости доставки, которая обновляет оценки RTprop и BtlBw:
```
function onAck(packet)
rtt = now - packet.sendtime
update_min_filter(RTpropFilter, rtt)
delivered += packet.size
delivered_time = now
deliveryRate = (delivered - packet.delivered) / (delivered_time - packet.delivered_time)
if (deliveryRate > BtlBwFilter.currentMax || ! packet.app_limited)
update_max_filter(BtlBwFilter, deliveryRate)
if (app_limited_until > 0)
app_limited_until = app_limited_until — packet.size
```
Проверка `if` нужна из-за проблемы неопределённости, о которой говорилось в последнем параграфе: отправители могут быть ограничены приложением, то есть у приложения могут закончиться данные для заполнения сети. Это довольно типичная ситуация из-за трафика запрос/ответ. Когда есть возможность для отправки, но никакие данные не отправляются, BBR помечает соответствующие образцы пропускной способности как «ограниченные приложением», то есть app\_limited (см. псевдокод `send()`). Этот код определяет, какие образцы включать в модель пропускной способности, так что он отражает именно сетевые ограничения, а не лимиты приложения. BtlBw является твёрдым верхним ограничением скорости доставки, так что полученная по результатам измерения скорость доставки большая, чем текущая оценка BtlBw, должна означать заниженную оценку BtlBw, независимо от того, был ли образец ограничен приложением или нет. В противном случае образцы с ограничением приложения отбрасываются. (Рисунок 1 показывает, что в регионе с ограничением приложения `deliveryRate` параметр BtlBw занижен). Такие проверки предотвращают заполнение фильтра BtlBw заниженными значениями, из-за которых отправка данных может замедлиться.
**Когда данные отправляются**
Для соотнесения скорости прибытия пакетов со скоростью вылета из узкого места BBR отслеживает каждый пакет данных. (BBR должен соответствовать *rate* узкого места: это значит, что отслеживание является неотъемлемой частью архитектуры и фундаментальной частью работы — поэтому *pacing\_rate* является основным контрольным параметром. Вспомогательный параметр *cwnd\_gain* связывает *inflight* с небольшим множеством BDP для обработки типичных патологий сети и получателя (см. ниже главу по задержанным и растянутым подтверждениям). Концептуально, процедура `send` в TCP выглядит как следующий код. (В Linux отправка данных использует эффективную процедуру массового обслуживания FQ/pacing [4], которая обеспечивает BBR линейную производительность одиночного соединения на мультигигабитных каналах и обрабатывает тысячи соединений с более низкой скоростью с незначительным оверхедом CPU).
```
function send(packet)
bdp = BtlBwFilter.currentMax × RTpropFilter.currentMin
if (inflight >= cwnd_gain × bdp)
// wait for ack or retransmission timeout
return
if (now >= nextSendTime)
packet = nextPacketToSend()
if (! packet)
app_limited_until = inflight
return
packet.app_limited = (app_limited_until > 0)
packet.sendtime = now
packet.delivered = delivered
packet.delivered_time = delivered_time
ship(packet)
nextSendTime = now + packet.size / (pacing_gain × BtlBwFilter.currentMax)
timerCallbackAt(send, nextSendTime)
```
**Поведение в устойчивом состоянии**
Скорость и количество данных, отправляемых по BBR, зависит только от BtlBw и RTprop, так что фильтры контролируют не только оценки ограничений узкого места, но и их применение. Это создаёт нестандартный контур управления, изображённый на рисунке 2, на котором показаны RTT (синим), inflight (зелёным) и скорость доставки (красным) на протяжении 700 миллисекунд для 10-мегабитного 40-миллисекундного потока. Жирная серая линия над скоростью доставки — это состояние фильтра BtlBw max. Треугольные формы получаются от цикличного применения коэффициента pacing\_gain в BBR для определения увеличения BtlBw. Коэффициент передачи в каждой части цикла показан выровненным по времени с данными, на которые он повлиял. Этот коэффициент сработал на RTT раньше, когда данные отправлялись. Это показано горизонтальными неровностями в описании последовательности событий с левой стороны.
*Рисунок 2*
BBR сводит к минимум задержку, потому что основная часть времени проходит с одной и той же BDP в действии. За счёт этого узкое место передвигается к отправителю, так что увеличение BtlBw становится незаметным. Следовательно, BBR периодически тратит интервал RTprop на значении pacing\_gain > 1, которое увеличивает скорость отправки и объём отправленных данных без подтверждения доставки (inflight). Если BtlBw не меняется, то очередь создаётся перед узким местом, увеличивая RTT, что сохраняет неизменным показатель `deliveryRate`. (Очередь можно устранить, отправляя данные с компенсирующим значением pacing\_gain < 1 для следующего RTprop). Если BtlBw увеличивается, то скорость `deliveryRate` тоже увеличивается, а новое максимальное значение фильтра немедленно увеличивает базовую скорость отслеживания (*pacing\_rate*). По этой причине BBR приспосабливается к новому размеру узкого места экспоненциально быстро. Рисунок 3 показывает этот эффект на 10-мегабитном 40-миллисекундном потоке, который BtlBw внезапно увеличивает до 20 Мбит/с после 20 секунд устойчивой работы (в левой части графика), затем сбрасывает до 10 Мбит/с после ещё 20 секунд устойчивой работы на 20 Мбит/с (правая часть графика).
*Рисунок 3*
(По сути, BBR — это простой пример управляющей системы «макс-плюс», нового подхода к системам управления, основанном на нестандартной макс-плюс алгебре [12]. Этот подход позволяет адаптировать скорость [управляется коэффициентом передачи *max*] независимо от роста очереди [управляется коэффициентом передачи *average*]. В применении к нашей задаче это сводится к простому, безусловному контуру управления, где адаптация к изменениям физических ограничений автоматически осуществляется изменением фильтров, выражающих эти ограничения. Традиционная система потребовала бы создания множества контуров управления, объединённых в сложный конечный автомат, чтобы добиться такого результата).
Поведение при запуске одиночного потока BBR
===========================================
Современные реализации обрабатывают события вроде запуска (startup), закрытия (shutdown) и возмещения потерь (loss recovery) с помощью алгоритмов, реагирующих на «события», с большим количеством строк кода. В BBR используется код, приведённый выше (в предыдущей главе «Сопоставление потока пакетов с путём доставки»), для всего. Обработка событий происходит путём прохода через последовательность «состояний». Сами «состояния» определены таблицей с одним или несколькими фиксированными значениями коэффициентов и критериев выхода. Основное время тратится в состоянии ProbeBW, которое описано в главе «Поведение в устойчивом состоянии». Состояния Startup и Drain используются при запуске соединения (рисунок 4). Чтобы обрабатывать соединение, где пропускная способность увеличивается на 12 порядков, в состоянии Startup реализован алгоритм двоичного поиска для BtlBw, где используется коэффициент передачи  для двукратного увеличения скорости передачи, когда увеличивается скорость доставки. Так определяется BtlBw в  RTT, но в то же время создаёт излишнюю очередь до . Как только Startup находит BtlBw, система BBR переходит в состояние Drain, которое использует обратные коэффициенты передачи Startup, чтобы избавиться от излишней очереди, а затем — в состояние ProbeBW, как только inflight опускается до линии BDP.
*Рисунок 4*
Рисунок 4 показывает первую секунду 10-мегабитного 40-миллисекундного потока BBR. На верхнем графике отложено время и последовательность событий, а также прогресс отправителя (зелёным) и получателя (синим): объём переданных и полученных данных. Красная линия показывает показатели отправителя по технологии CUBIC при тех же условиях. Вертикальные серые линии означают моменты перехода между состояниями BBR. На нижнем графике — изменение времени двойного прохода пакетов (RTT) обоих соединений. Обратите внимание, что шкала времени для этого графика соответствует времени получения подтверждения о прибытии (ack). Поэтому может показаться, что графики будто смещены во времени, но на самом деле события внизу соответствуют тем моментам, когда система BBR узнаёт об этих событиях и реагирует.
Нижний график на рисунке 4 сравнивает BBR и CUBIC. Сначала их поведение почти одинаково, но BBR полностью опустошает образовавшуюся при запуске соединения очередь, а CUBIC не может этого сделать. У неё нет модели трассы, которая сообщила бы, сколько отправленных данных являются излишними. Поэтому CUBIC менее агрессивно наращивает передачу данных без подтверждения доставки, но этот рост продолжается до тех пор, пока буфер узкого места не переполнится и не начнёт отбрасывать пакеты, или до достижения лимита у получателя на отправленные данные без подтверждения (окно приёма TCP).
Рисунок 5 показывает поведение RTT в первые восемь секунд соединения, изображённого на предыдущем рисунке 4. Технология CUBIC (красным) заполняет весь доступный буфер, затем крутится между 70% и 100% заполнения каждые несколько секунд. После запуска соединения BBR (зелёным) работает практически без создания очереди.
*Рисунок 5*
Поведение, когда несколько потоков BBR встречаются в узком месте
================================================================
Рисунок 6 показывает, как пропускная способность нескольких потоков BBR сходится в честном разделе канала с узким местом на 100 мегабит/10 миллисекунд. Смотрящие вниз треугольные структуры — состояния соединений ProbeRTT, в которых самосинхронизация ускоряет окончательную конвергенцию.
*Рисунок 6*
Циклы изменения коэффициентов усиления ProbeBW (рисунок 2) стимулируют бóльшие потоки уступать полосу меньшим потокам, в результате чего каждый поток понимает своё честное состояние. Это происходит довольно быстро (несколько циклов ProbeBW), хотя несправедливость может сохраняться, если опоздавшие к началу передела потоки переоценивают RTprop из-за того, что начавшие ранее потоки (временно) создают очередь.
Чтобы выяснить настоящий RTProp, поток перемещается налево от линии BDP, используя состояние ProbeRTT: если оценка RTProp не обновляется (то есть путём замера меньшего RTT) в течение многих секунд, то BBR входит в состояние ProbeRTT, уменьшая количество отправляемых данных (inflight) до четырёх пакетов по крайней мере для одного двойного прохода, а затем возвращается в предыдущее состояние. Когда большие потоки входят в состояние ProbeRTT, то из очереди изымается много пакетов, так что сразу несколько потоков видят новое значение RTprop (новое минимальное RTT). Благодаря этому их оценки RTprop обнуляются одновременно, так что они все вместе входят в состояние ProbeRTT — и очередь уменьшается ещё сильнее, в результате чего ещё больше потоков видят новое значение RTprop, и так далее. Такая распределённая координация — ключевой фактор одновременно для честного распределения полосы и стабильности.
BBR синхронизирует потоки вокруг желаемого события, коим является пустая очередь в узком месте. В противоположность такому подходу, регулирование заторов по потере пакетов синхронизирует потоки вокруг нежелательных событий, таких как периодический рост очереди и переполнение буфера, что увеличивает задержку и потерю пакетов.
Опыт внедрения B4 WAN в Google
==============================
Сеть B4 в компании Google — это высокоскоростная сеть WAN (wide-area network), построенная на обычных дешёвых коммутаторах [15]. Потери на этих коммутаторах с мелкими буферами происходят в основном из-за случайного наплыва небольших всплесков трафика. В 2015 году Google начала переводить рабочий трафик с CUBIC на BBR. Не было зафиксировано никаких проблем или регрессий, а с 2016 года весь трафик B4 TCP использует BBR. Рисунок 7 иллюстрирует одну причину, по которой это было сделано: пропускная способность BBR неизменно в 2-25 раз выше, чем у CUBIC. Мы видели даже большее улучшение, но обнаружили, что 75% соединений BBR ограничены буфером приёма TCP в ядре, который сотрудники отдела эксплуатации сети сознательно установили на низкое значение (8 МБ), чтобы не дать CUBIC заполонить сеть мегабайтами избыточного трафика без подтверждения доставки (если разделить 8 МБ на 200 мс межконтинентального RTT, то получится 335 Мбит/с максимум). Ручное увеличение буфера приёма на на одном маршруте США−Европа мгновенно повысило скорость передачи данных BBR до 2 Гбит/с, в то время как CUBIC остался на 15 Мбитах/с — это 133-кратное относительное увеличение пропускной способности было предсказано Мэтисом с коллегами в научной работе 1997 года. [17]
*Рисунок 7*
Рисунок 7 показывает относительное улучшение BBR по сравнению с CUBIC; на врезке — интегральные функции распределения (cumulative distribution functions, CDF) для пропускной способности. Замеры произведены с помощью службы активного зондирования, которая открывает постоянные соединения BBR и CUBIC к удалённым дата-центрам, затем каждую минуту передаёт по 8 МБ данных. Зонды исследуют много маршрутов B4 между Северной Америкой, Европой и Азией.
Огромное улучшение — прямое следствие того, что BBR *не* использует потерю пакетов как индикатор затора. Для достижения полной пропускной способности существующим методам регулирования заторов по потере пакетов нужно, чтобы уровень потерь был меньше, чем обратный квадрат BDP [17] (например, менее одной потери на 30 миллионов пакетов для соединения 10 Гбит/с и 100 мс). На рисунке 8 сравнивается измеренная полезная пропускная способность на различных уровнях потерь пакетов. В алгоритме CUBIC допуск на потерю пакетов является структурным свойством алгоритма, а в BBR это параметр конфигурации. По мере того, как уровень потерь в BBR приближается к максимальному коэффициенту усиления ProbeBW, вероятность измерения скорости доставки реального BtlBw резко падает, что приводит к недооценке со стороны фильтра max.
*Рисунок 8*
Рисунок 8 сравнивает полезную пропускную способность BBR и CUBIC в 60-секундном потоке на соединении 100 Мбит/c и 100 мс со случайными потерями от 0,001% до 50%. Пропускная способность CUBIC уменьшается в 10 раз при потерях 0,1% и полностью глохнет при более 1%. Максимальной пропускной способностью считается доля полосы за минусом потерь пакетов (). BBR держится на этом уровне до уровня потерь 5% и близко к нему до 15%.
Опыт внедрения YouTube Edge
===========================
BBR развёртывается на видеосерверах YouTube и Google.com. Google проводит небольшой эксперимент, в рамках которого малый процент пользователей случайно переводят на BBR или CUBIC. Воспроизведение видео по BBR показывает значительно улучшение всех оценок пользователями качества услуги. Возможно, потому что поведение BBR более последовательное и предсказуемое. BBR лишь немного улучшает пропускную способность соединения, потому что YouTube и так адаптирует скорость потоковой передачи до уровня гораздо ниже BtlBw, чтобы свести к минимуму излишнюю сетевую буферизацию и повторную буферизацию. Но даже здесь BBR уменьшает среднее медианное RTT на 53% в целом по миру и более чем на 80% в развивающихся странах.
Рисунок 9 показывает медианное улучшение RTT в сравнении BBR и CUBIC по статистике более 200 млн просмотров видео на YouTube, измеренных на пяти континентах в течение недели. Более половины из всех 7 млрд мобильных соединений в мире подключаются по 2.5G на скорости от 8 до 114 Кбит/с [5], испытывая хорошо задокументированные проблемы из-за того, что методы регулирования заторов по потере пакетов склонны переполнять буферы [3]. Узкое место в этих системах обычно находится между SGSN (обслуживающий узел поддержки GPRS) [18] и мобильным устройством. Программное обеспечение SGSN работает а стандартной платформе ПК с обильным количеством ОЗУ, где часто имеются мегабайты буфера между интернетом и мобильным устройством. Рисунок 10 сравнивает (эмулированную) задержку SGSN между интернетом и мобильным устройством для BBR и CUBIC. Горизонтальные линии отмечают одни из наиболее серьёзных последствий: TCP адаптируется к длительным задержкам RTT за исключением пакета SYN, инициирующего соединение, у которого фиксированный таймаут, в зависимости от операционной системы. Когда мобильное устройство получает большой массив данных (например, от автоматического обновления программного обеспечения) через SGSN с большим буфером, устройство не может установить никакое соединение в интернете, пока очередь не освободится (подтверждающий пакет SYN ACK задерживается на большее время, чем фиксированный таймаут SYN).
*Рисунок 9*
Рисунок 10 показывает медианные изменения RTT в устойчивом состоянии соединения и зависимость от размера буфера на соединении 128 Кбит/с и 40 мс с восемью потоками BBR (зелёным) или CUBIC (красным). BBR удерживает очередь у минимальных значений, независимо от размера буфера узкого места и количества активных потоков. Потоки CUBIC всегда заполняют буфер, так что задержка увеличивается линейно с размером буфера.
*Рисунок 10*
Адаптивная полоса в мобильной сотовой связи
===========================================
Сотовые системы адаптируют полосу пропускания для каждого пользователя частично в зависимости от прогноза запросов, в котором учитывается очередь пакетов, предназначенная для этого пользователя. Ранние версии BBR были настроены таким образом, чтобы создавать очень маленькие очереди, из-за чего соединения стопорились на низких скоростях. Увеличение пикового значения pacing\_gain для ProbeBW и увеличение очередей привело к уменьшению заглохших соединений. Это показывает возможность великолепной адаптации для некоторых сетей. С текущим значением пикового коэффициента усиления  не проявляется никакой деградации ни в какой сети, по сравнению с CUBIC.
Задержанные и растянутые пакеты ack
===================================
Сети сотовой связи, WiFi и широкополосные сети часто задерживают и скапливают пакеты ack [1]. Когда inflight ограничивается одним BDP, это приводит к срывам, снижающим пропускную способность. Увеличение коэффициента cwnd\_gain ProbeBW до двух позволило продолжить ровную передачу на прогнозируемой скорости доставки, даже когда пакеты ack задерживались до значения в один RTT. Это в значительной степени предотвращает срывы.
Ограничители текущего ведра
===========================
Первоначальное развёртывание BBR на YouTube показал, что большинство интернет-провайдеров в мире искажают трафик с помощью ограничителей скорости по алгоритму текущего ведра [7]. Ведро обычно полно в начале соединения, так что BBR узнаёт параметр BtlBw для лежащей в основе сети. Но как только ведро опустошается, то все пакеты, отправленные быстрее, чем (намного меньшая, чем BtlBw) скорость наполнения ведра, отбрасываются. BBR в конце концов узнаёт эту новую скорость доставки, но цикличное изменение коэффициента усиления ProbeBW приводит к постоянным умеренным потерям. Чтобы минимизировать потери полосы восходящего потока и увеличение задержек приложения от этих потерь, мы добавили специальный детектор ограничителей и явную модель ограничителей в BBR. Мы также активно изучаем лучшие способы устранить вред от работы ограничителей скорости.
Конкуренция с методами регулирования заторов по потерям пакетов
===============================================================
BBR сводится к честному разделению полосы пропускания узкого места, будь то в конкуренции с другими потоками BBR или с потоками под управлением методов регулирования заторов по потерям пакетов. Даже когда последние заполняют доступный буфер, ProbeBW всё ещё надёжно сдвигает оценку BtlBw в сторону честного разделения потоков, а ProbeRTT считает оценку RTProp достаточно высокой для сходимости «око за око» к честному разделению. Однако неуправляемые буферы маршрутизаторов, превышающие некоторые BDP, заставляют устаревших конкурентов с регулированием заторов по потерям пакетов раздувать очередь и захватывать больше, чем им причитается по-честному. Устранение этого — ещё одна область активных исследований.
Заключение
==========
Переосмысление методов регулирования заторов приносит огромную пользу. Вместо использования событий, таких как потери или занятие буфера, которые лишь слабо коррелируют с заторами, BBR начинает с формальной модели заторов Клейнрока и связанной с ней оптимальной рабочей точки. Досадный вывод о «невозможности» одновременного определения критически важных параметров задержки и полосы пропускания обходится с помощью наблюдения, что их можно прогнозировать одновременно. Затем последние достижения в системах управления и теории оценивания применяются для создания простого распределённого контура управления, который приближается к оптимуму, полностью используя сеть при сохранении маленькой очереди. Реализация BBR от Google доступна в ядре Linux с открытым исходным кодом и детально описана в приложении к этой статье.
Технология BBR используется на бэкбоне Google B4, на порядки улучшая пропускную способность по сравнению с CUBIC. Она также разворачивается на веб-серверах Google и YouTube, в значительной степени уменьшая задержку на всех пяти континентах, протестированных к настоящему времени, а особенно сильно в развивающихся странах. Технология BBR работает исключительно на стороне отправителя и не требует изменений в протоколе, у получателя или в сети, что позволяет развёртывать её постепенно. Она зависит только от RTT и уведомлений о доставке пакетов, так что её можно применять в большинстве транспортных протоколов интернета.
C авторами можно связаться по адресу bbr-dev@googlegroups.com.
**Выражение признательности**
Авторы благодарны Лену Клейнроку за указание, как нужно правильно регулировать заторы. Мы в долгу перед Ларри Бракмо (Larry Brakmo) за новаторскую работу над системами регулирования заторов Vegas [2] и New Vegas, которые предвосхитили многие элементы BBR, а также за его советы и руководство на начальном этапе разработки BBR. Мы также хотели бы поблагодарить Эрика Думазета (Eric Dumazet), Нандиту Дуккипати (Nandita Dukkipati), Яну Айенгар (Jana Iyengar), Яна Светта (Ian Swett), Фитца Ноулана (M. Fitz Nowlan), Дэвида Уэзерала (David Wetherall), Леонидаса Контотанассиса (Leonidas Kontothanassis), Амина Вахдата (Amin Vahdat) и группы разработки Google BwE и инфраструктуры YouTube за их неоценимую помощь и поддержку.
Приложение — подробное описание
===============================
**Машина состояний для последовательного зондирования**
Коэффициент усиления pacing\_gain управляет, как быстро отправляются пакеты относительно BtlBw, и это ключ к интеллектуальной функции BBR. При pacing\_gain больше единицы увеличивается inflight и уменьшается промежуток между поступлениями пакетов, что передвигает соединение в правую часть на рисунке 1. При pacing\_gain меньше единицы происходит обратный эффект, соединение передвигается влево.
BBR использует pacing\_gain для реализации простой машины последовательного зондирования состояний, которая чередуется между тестированием на бóльшую полосу и тестированием на меньшее время двойного прохода пакета. (Необязательно тестировать на меньшую полосу, потому что она обрабатывается автоматически фильтром BtlBw msx: новые измерения отражают падение, так что BtlBw скорректирует себя сразу, как только последние старые изменения уберутся из фильтра по таймауту. Фильтр RTprop min таким же образом обрабатывает увеличение пути доставки).
Если увеличивается пропускная способность бутылочного горлышка, BBR должен отправлять данные быстрее, чтобы обнаружить это. Точно так же, если меняется реальное время двойного прохода пакета, это меняет BDP, и поэтому BDP должен отправлять данные медленнее, чтобы удержать inflight ниже BDP для измерения нового RTprop. Поэтому единственный способ обнаружить эти изменения — проведение экспериментов, отправляя быстрее для проверки увеличения BtlBw или отправляя медленнее для проверки уменьшения RTprop. Частота, масштаб, продолжительность и структура этих экспериментов различаются в зависимости от того, что уже известно (запуск соединения или стабильное состояние) и от поведения приложения, которое отправляет данные (прерывистое или постоянное).
**Устойчивое состояние**
Потоки BBR тратят бóльшую часть своего времени в состоянии ProbeBW, зондируя полосу с помощью метода под названием *gain cycling*, что помогает потокам BBR достичь высокой пропускной способности, низкой задержки в очереди и сходимости в честном разделе полосы. Используя *gain cycling*, BBR циклично пробует ряд значений для коэффициента усиления *pacing\_gain*. Используется восемь фаз цикла со следующими значениями: 5/4, 3/4, 1, 1, 1, 1, 1, 1. Каждая фаза обычно идёт в течение прогнозируемого RTprop. Такой дизайн позволяет циклу коэффициента сначала зондировать канал на бóльшую пропускную способность со значением *pacing\_gain* больше 1.0, а затем рассредотачивать любую образовавшуюся очередь с помощью *pacing\_gain* на такую же величину меньше 1.0, а затем двигаться на крейсерской скорости с короткой очередью коэффициентов ровно 1.0. Средний коэффицент усиления для всех фаз равняется 1.0, потому что ProbeBW стремится к среднему значению, чтобы уравняться с доступной полосой пропускания и, следовательно, сохранить высокую степень использования полосы, не увеличивая при этом очередь. Обратите внимание, что хотя циклы изменений коэффицента изменяют *pacing\_gain*, но значение *cwnd\_gain* неизменно остаётся равным двум, поскольку задержанные и растянутые пакеты подтверждения могут появиться в любой момент (см. главу о задержанных и растянутых пакетах ack).
Более того, для улучшения смешивания потоков и справедливого разделения полосы, и для уменьшения очередей, когда многочисленные потоки BBR совместно используют узкое место, BBR случайным образом изменяет фазы цикла ProbeBW, случайно выбирая первую фазу среди всех значений, кроме 3/4. Почему цикл не начинается с 3/4? Главная задача этого значения коэффициента — рассредоточить любую очередь, которая может образоваться во время применения коэффициента 5/4, когда канал уже полный. Когда процесс выходит из состояния Drain или ProbeRTT и входит в ProbeBW, то очередь отсутствует, так что коэффициент 3/4 не выполняет свою задачу. Применение 3/4 в таком контексте имеет только негативный эффект: заполнение канала в этой фазе будет 3/4, а не 1. Таким образом, начало цикла с 3/4 имеет только негативный эффект, но не имеет положительного, а поскольку вход в состояние ProbeBW происходит на старте любого соединения достаточно долго, то BBR использует эту маленькую оптимизацию.
Потоки BBR действуют сообща, чтобы периодически опустошать очередь в узком месте при помощи состояния, которое называется ProbeRTT. В любом состоянии кроме самого ProbeRTT, если оценка RTProp не обновлялась (например, посредством замера меньшего RTT) более 10 секунд, то BBR входит в состояние ProbeRTT и уменьшает cwnd до очень маленького значения (четыре пакета). Сохраняя такое минимальное количество пакетов «в полёте» по крайней мере 200 мс и на протяжении одного времени двойного прохода пакета, BBR выходит из состояния ProbeRTT и входит или в Startup, или в ProbeBW, в зависимости от оценки, заполнен ли уже канал.
BBR создан, чтобы работать бóльшую часть времени (около 98%) в состоянии ProbeBW, а остальное время — в ProbeRTT, основываясь на наборе компромиссов. Состояние ProbeRTT продолжается достаточно долго (по крайней мере, 200 мс), чтобы позволить потокам с разными RTT иметь параллельные состояния ProbeRTT, но в то же время оно продолжается достаточно короткий промежуток времени, чтобы ограничить снижение производительности примерно двумя процентами (200 мс / 10 секунд). Окно фильтра RTprop (10 секунд) достаточно маленькое, чтобы быстро подстроиться под изменение уровня трафика или изменение маршрута, но при этом достаточно большое для интерактивных приложений. Такие приложения (например, веб-страницы, вызовы удалённых процедур, фрагменты видео) часто демонстрируют естественные периоды молчания или малой активности в раках этого окна, где скорость потока достаточно низкая или достаточно продолжительная, чтобы рассредоточить очередь в узком месте. Затем фильтр RTprop оппортунистически подбирает эти измерения RTprop, а RTProp обновляется без необходимости задействовать ProbeRTT. Таким образом, потокам обычно требуется всего лишь жертвовать 2% полосы, если многочисленные потоки обильно заполняют канал на протяжении целого окна RTProp.
**Поведение при запуске**
Когда запускается поток BBR, он осуществляет свой первый (и самый быстрый) последовательный процесс зондирования/опустошения очереди. Сетевая пропускная способность изменяется в диапазоне 1012 — от нескольких бит до 100 гигабит в секунду. Чтобы выяснить значение BtlBw при таком гигантском изменении диапазона, BBR осуществляет двоичный поиск в пространстве скорости. Он очень быстро находит BtlBw ( двойных проходов пакетов), но за счёт создания очереди в 2BDP на последнем этапе поиска. Поиск выполняется в состоянии Startup в BBR, а опустошение создавшейся очереди — в состоянии Drain.
Сначала Startup экспоненциально увеличивает скорость отправки данных, удваивая её на каждом раунде. Чтобы добиться такого быстрого зондирования наиболее спокойным образом, при запуске значения коэффициентов усиления *pacing\_gain* и *cwnd\_gain* установлены на , в минимальное значение, которое позволяет удваивать скорость отправки данных на каждом раунде. Как только канал заполняется, коэффициент *cwnd\_gain* ограничивает размер очереди значением .
В состоянии запуска соединения BBR оценивает, заполнен ли канал, с помощью поиска плато в оценке BtlBw. Если обнаруживается, что прошли несколько (три) раунда, где попытки удвоить скорость доставки реально не даёт большой прибавки скорости (менее 25%), то он считает, что достиг BtlBw, так что выходит из состояния Startup и входит в состояние Drain. BBR ждёт три раунда, чтобы получить убедительные доказательства, что наблюдаемое отправителем плато скорости доставки не является временным эффектом под влиянием окна приёма. Ожидание трёх раундов даёт достаточно времени для автоматической настройки на стороне получателя, чтобы раскрыть окно приёма и чтобы отправитель по BBR обнаружил необходимость увеличения BtlBw: в первом раунде алгоритм автоматической настройки окна приёма увеличивает окно приёма; во втором раунде отправитель заполняет увеличившееся окно приёма; в третьем раунде отправитель получает образцы с увеличенной скоростью доставки. Такой предел в три раунда доказал себя по результатам внедрения на YouTube.
В состоянии Drain алгоритм BBR стремится быстро опустошить очередь, которая образовалась в состоянии запуска соединения, перейдя в режим *pacing\_gain* с обратными значениями, чем те, которые использовались в состоянии Startup. Когда количество пакетов в полёте соответствует оценке BDP, это означает, что BBR оценивает очередь как полностью опустошённую, но канал по-прежнему заполнен. Тогда BBR выходит из состояния Drain и входит в ProbeBW.
Заметьте, что запуск соединения BBR и медленный старт CUBIC оба изучают пропускную способность узкого места экспоненциально, удваивая скорость отправки на каждом раунде. Однако они кардинально отличаются. Во-первых, BBR более надёжно определяет доступную пропускную способность, поскольку он не прекращает поиск в случае потери пакета или (как Hystart у CUBIC [10]) увеличения задержки. Во-вторых, BBR плавно наращивает скорость отправки, в то время как у CUBIC на каждом раунде (даже с pacing) происходит всплеск пакетов, а потом период тишины. Рисунок 4 показывает количество пакетов в полёте и наблюдаетмое время RTT для каждого сообщения о подтверждении у BBR и CUBIC.
**Реагирование на переходные ситуации**
Сетевой путь и проход трафика по нему могут испытывать внезапные драматические изменения. Чтобы плавно и надёжно адаптироваться к ним, а также уменьшить потери пакетов в этих ситуациях, BBR использует ряд стратегий, чтобы реализовать свою базовую модель. Во-первых, BBR расценивает  как цель, к которой текущий *cwnd* осторожно приближается снизу, увеличивая *cwnd* каждый раз не более чем на количество данных, для которых пришли подтверждения доставки. Во-вторых, при таймауте повторной передачи, который означает, что отправитель считает потерянными все пакеты в полёте, BBR консервативно снижает *cwnd* до одного пакета и отправляет единственный пакет (точно как алгоритмы регулирования заторов по потере пакетов, такие как CUBIC). В конце концов, когда отправитель замечает потерю пакета, но в полёте всё ещё есть пакеты, на первом этапе процесса по восстановлению потерь BBR временно снижает скорость отправки до уровня текущей скорости доставки; на втором и последующих раундах восстановления потерь он проверяет, что скорость отправки никогда не превышает текущую скорость доставки более чем в два раза. Это значительно снижает потери в переходных ситуациях, когда BBR сталкивается с ограничителями скорости или конкурирует с другими потоками в буфере, сравнимого размером с BDP.
Ссылки
======
1. Abrahamsson, M. 2015. TCP ACK suppression. Почтовый список рассылки IETF AQM; <https://www.ietf.org/mail-archive/web/aqm/current/msg01480.html>.
2. Brakmo, L. S., Peterson, L.L. 1995. TCP Vegas: end-to-end congestion avoidance on a global Internet. IEEE Journal on Selected Areas in Communications 13(8): 1465-1480.
3. Chakravorty, R., Cartwright, J., Pratt, I. 2002. Practical experience with TCP over GPRS. In IEEE GLOBECOM.
4. Corbet, J. 2013. TSO sizing and the FQ scheduler. LWN.net; <https://lwn.net/Articles/564978/>.
5. Ericsson. 2015 Ericsson Mobility Report (июнь); <https://www.ericsson.com/res/docs/2015/ericsson-mobility-report-june-2015.pdf>.
6. ESnet. Application tuning to optimize international astronomy workflow from NERSC to LFI-DPC at INAF-OATs; <http://fasterdata.es.net/data-transfer-tools/case-studies/nersc-astronomy/>.
7. Flach, T., Papageorge, P., Terzis, A., Pedrosa, L., Cheng, Y., Karim, T., Katz-Bassett, E., Govindan, R. 2016. An Internet-wide analysis of traffic policing. ACM SIGCOMM: 468-482.
8. Gail, R., Kleinrock, L. 1981. An invariant property of computer network power. Conference Record, International Conference on Communications: 63.1.1-63.1.5.
9. Gettys, J., Nichols, K. 2011. Bufferbloat: dark buffers in the Internet. acmqueue 9(11); <http://queue.acm.org/detail.cfm?id=2071893>.
10. Ha, S., Rhee, I. 2011. Taming the elephants: new TCP slow start. Computer Networks 55(9): 2092-2110.
11. Ha, S., Rhee, I., Xu, L. 2008. CUBIC: a new TCP-friendly high-speed TCP variant. ACM SIGOPS Operating Systems Review 42(5): 64-74.
12. Heidergott, B., Olsder, G. J., Van Der Woude, J. 2014. Max Plus at Work: Modeling and Analysis of Synchronized Systems: a Course on Max-Plus Algebra and its Applications. Princeton University Press.
13. Jacobson, V. 1988. Congestion avoidance and control. ACM SIGCOMM Computer Communication Review 18(4): 314-329.
14. Jaffe, J. 1981. Flow control power is nondecentralizable. IEEE Transactions on Communications 29(9): 1301-1306.
15. Jain, S., Kumar, A., Mandal, S., Ong, J., Poutievski, L., Singh, A., Venkata, S., Wanderer, J., Zhou, J., Zhu, M., et al. 2013. B4: experience with a globally-deployed software defined WAN. ACM SIGCOMM Computer Communication Review 43(4): 3-14.
16. Kleinrock, L. 1979. Power and deterministic rules of thumb for probabilistic problems in computer communications. In Conference Record, International Conference on Communications: 43.1.1-43.1.10.
17. Mathis, M., Semke, J., Mahdavi, J., Ott, T. 1997. The macroscopic behavior of the TCP congestion avoidance algorithm. ACM SIGCOMM Computer Communication Review 27(3): 67-82.
18. Википедия. Обслуживающий узел поддержки GPRS в базовой сети GPRS; <https://en.wikipedia.org/wiki/GPRS_core_network#Serving_GPRS_support_node_.28SGSN.29>.
**Статьи по теме**
«[Буферы на стороне отправителя и случай адаптации для мультимедиа](http://queue.acm.org/detail.cfm?id=2381998)»
Aiman Erbad, Charles «Buck» Krasic
«[Что вы не знали о сетевой производительности](http://queue.acm.org/detail.cfm?id=1066069)»
Kevin Fall, Steve McCanne
«[Экскурсия по сетевой инфраструктуре дата-центра](http://queue.acm.org/detail.cfm?id=2208919)»
Dennis Abts, Bob Felderman
Авторы статьи — участники проекта Google make-tcp-fast, цель которого — развитие транспортной системы интернета посредством фундаментальных исследований и свободного программного обеспечения. Вкладом проекта стали TFO (TCP Fast Open), TLP (Tail Loss Probe), система возмещения потерь RACK, fq/pacing и значительная часть коммитов git в код TCP ядра Linux за последние пять лет. | https://habr.com/ru/post/322430/ | null | ru | null |
# Установка в Alt Linux специализированного ПО, защищенного ключами Guardant, на примере ГосСтройСмета
В своей предыдущей статье ([Настройка Linux для инженера-ПТО/инженера-сметчика ч.2](https://habr.com/ru/post/663726/)), которая тепло была принята в профессиональном сообществе, я рассказывал о том как подготовиться инженеру строительного производства к офисной работе в операционной системе Linux. Отечественное лицензионное инженерное программное обеспечение, зачастую, использует для защиты электронные ключи [Guardant](https://www.guardant.ru). [Я уже рассказывал](https://habr.com/ru/post/667456/) о том, как можно настроить работу таких приложений в операционных системах [Debian Linux](https://cdimage.debian.org/cdimage/unofficial/non-free/cd-including-firmware/) и [Astra Linux](https://astralinux.ru/products/). Сегодня речь пойдет о том как можно установить такое программное обеспечение на примере [ГосСтройСмета](https://www.gosstroysmeta.ru/index.php) в Российской операционной системе [Alt Linux](https://alt-linux.ru).
**Фотография ключа защиты**
### 1. Пара слов о ПО ...
**и ключах защиты Guardant**
Здесь я вынужден коротко поторить все то, что писал в других своих тематических статьях:
> Guardant — это ряд аппаратных и программных разработок в сфере защиты софта от нелегального копирования, анализа и модификации. Электронные ключи Guardant защищают миллионы продуктов по всему миру и работают в основе DRM для защиты разнообразного контента. Программные технологии виртуализации кода и софтверные ключи органично дополняют современную линейку продуктов Guardant.
Применяемое в строительстве лицензионное ПО (программное обеспечение) от российских разработчиков, так исторически сложилось, зачастую использует физические ключи для защиты именно этого производителя. Такие Ключи и ПО, в первую очередь, рассчитаны на работу в операционной системе MS Windows, но, [согласно комментариям от разработчиков ключа](https://dev.guardant.ru/display/KB/0008):
Работают ли ключи Guardant под Linux
> Да, работают. Нативная поддержка GNU/Linux реализована в моделях Guardant Sign / Time / Code, а так же в их сетевых версиях.
>
>
>
> Предыдущие модели электронных ключей Guardant (Guardant Stealth III / Net III / Stealth II USB / Net II USB) не могут работать под Linux «самостоятельно». Максимум, что можно сделать в этом случае — запускать Windows-приложение, защищенное с помощью этих ключей, в среде коммерческой сборки WINE@Etersoft.
Таким образом из этого следует что ключ будет виден программами в Wine в любом случае, но для работы с нативным ПО для Linux необходимы более свежие версии таких ключей.
Разработчиком [ALT Linux](https://alt-linux.ru) является [ООО «Базальт СПО»](https://www.basealt.ru/company) — российский разработчик операционных систем «Альт», 2015–2023. В свою очередь эта разработка базируется на проекте [Sisyphus (Сизиф)](https://www.altlinux.org/%D0%A7%D1%82%D0%BE_%D1%82%D0%B0%D0%BA%D0%BE%D0%B5_Sisyphus%3F), который разрабатывается международной, в основном русскоговорящей, командой разработчиков свободного программного обеспечения [ALT Linux Team](https://www.altlinux.org/ALT_Linux_Team).
[ALT Linux](https://alt-linux.ru) проводит собственную политику, не зависящую от иностранных дистрибутивов. Оперативное обновление пакетов производится с тотальной проверкой регрессий. Имеется собственная платформа конфигурирования [Alterator](https://www.altlinux.org/Alterator). [ALT Linux](https://alt-linux.ru) соблюдает стандарт [LSB](https://ru.wikipedia.org/wiki/Linux_Standard_Base), а так же осуществляется качественная поддержка вплоть до третьего уровня (разработчиков).
[ALT Linux](https://alt-linux.ru) является старейшим из ныне существующих отечественных/российских дистрибутивов Linux, разрабатываемый с 1999—2000 годов. Исторически [ALT Linux](https://alt-linux.ru) основывался на дистрибутиве [Mandrake Linux](https://ru.wikipedia.org/wiki/Mandriva_Linux) и представлял собой его русскую версию ([Linux-Mandrake Russian Edition](https://web.archive.org/web/20170325114417/https://www.alv.me/linux-mandrake-russkaya-reinkarnaciya/)). Для его разработки/развития в 2001 году было учреждено ООО «АЛЬТ ЛИНУКС».
7 апреля 2005 года [Mandrake](https://ru.wikipedia.org/wiki/Mandriva_Linux), сменила название на [Mandriva](https://ru.wikipedia.org/wiki/Mandriva_Linux). 28 августа 2011 года вышел последний релиз [Mandriva](https://ru.wikipedia.org/wiki/Mandriva_Linux). 27 мая 2015 года было официально объявлено о ликвидации компании [Mandriva](https://ru.wikipedia.org/wiki/Mandriva_Linux) (ранее [Mandrake Linux](https://ru.wikipedia.org/wiki/Mandriva_Linux)).
Начиная с 2000 года началось замещение пакетов [Mandrake](https://ru.wikipedia.org/wiki/Mandriva_Linux) собственными сборками, значительное изменение системы сборки и макросов пакетного менеджера RPM. К версии 3.0 (2005 год) все пакеты [Mandrake](https://ru.wikipedia.org/wiki/Mandriva_Linux), инсталлятор и система конфигурирования были полностью вытеснены собственными разработками ALT Linux Team. В 2015 году произошёл ребрендинг и компанией разработчиком стала ООО «БАЗАЛЬТ СПО». На текущий момент [ALT Linux](https://alt-linux.ru) является полностью самостоятельным проектом.
 — это современный комплекс программных продуктов с обширным функционалом для составления и проверки [проектно-сметной документации](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%BD%D0%BE-%D1%81%D0%BC%D0%B5%D1%82%D0%BD%D0%B0%D1%8F_%D0%B4%D0%BE%D0%BA%D1%83%D0%BC%D0%B5%D0%BD%D1%82%D0%B0%D1%86%D0%B8%D1%8F). Разработкой данного ПО с 2017 года занимается ООО «ГСС Плюс», являющейся, пожалуй, самой молодой компанией на рынке сметного ПО. В этом году ей исполняется 6 лет.
В состав этого комплекса входит не только [WEB-версия](https://gss-online.ru), но так же и десктопная, [«ГОССТРОЙСМЕТА» версия 3 («ГСС-3»)](https://www.gosstroysmeta.ru/products/download/), описание которой [доступно по этой ссылке](https://www.gosstroysmeta.ru/products/description/gss3/). Именно третья версия программы фактически заново родилась. Почему? Потому что ПО версий 1 и 2 создавали изначально, скажем так, упрощенно: ПРОСТОЕ. Без лишних наворотов. Естественно, покруче «Сметного калькулятора», но явно не дотягивающую до сметных «грандов».«ГСС-3» написали заново с чистого листа. При разработке делался упор на быстродействие, ПО может похвастаться интерфейсом [Ribbon](https://ru.wikipedia.org/wiki/%D0%9B%D0%B5%D0%BD%D1%82%D0%BE%D1%87%D0%BD%D1%8B%D0%B9_%D0%B8%D0%BD%D1%82%D0%B5%D1%80%D1%84%D0%B5%D0%B9%D1%81), все привычное для любителей функционала Excel. Настраиваемый импорт из любых форматов файлов сметных программ и работа с ними!
### 2. Установка и настройка ПО в системе Alt Linux
Для последующих тестов в этом разделе будет использоваться [Alt Linux Рабочая станция К 10.1](https://habr.com/ru/news/t/714048/) (версии с графическим окружением [KDE](https://kde.org))
**Пара слов о характеристиках ПК, на котором будет устанавливаться ПО**
Система виртуализации — [Proxmox](https://pve.proxmox.com/wiki/Main_Page) 7.3-4 (Последняя версия на момент написания статьи),
Гипервизор стоит на [ноутбуке Hasee ZX7-CT5DA (он же Clevo N957TC)](https://habr.com/ru/post/513964/)
Характеристики ноутбука:
ЦП — Intel Core i7-8700
ВК — GTX 1660Ti
ОЗУ — 16 GB
Установленные диски — 512GB Phison SSD SATA m.2/1TB Samsung EVO 970 SSD NVMe m.2/250GB Samsung EVO 850 SSD SATA 2.5"
Дисплей — 15,6 ''IPS 45% NTSC
Далее предполагается что Ваш локальный пользователь входит в группу Администраторы, операционная система и пакеты обновлены до самых свежих версий, а так же установлены драйвера на видеокарту от производителя и выключен Secure Boot.
Что бы установить ПО нам потребуется [WineHQ](https://www.winehq.org), для чего открываем [терминал/консоль](https://habr.com/ru/company/redmadrobot/blog/538446/) и поочередно прописываем следующие команды:
*(здесь и далее символ # означает новую строку. При копировании/вводе команд из этой статьи в Ваш(у) [терминал/консоль](https://habr.com/ru/company/redmadrobot/blog/538446/) его следует игнорировать)*
**2.1.** Установка [WineHQ](https://www.winehq.org) осуществляется на основе стать из [AltWiki](https://www.altlinux.org/WINE/howto)
`# sudo apt-get update` — обновляем заголовки актуального ПО из подключенных репозиториев
`# sudo apt-get install i586-wine wine-mono i586-glibc-nss i586-sssd-client i586-libGL i586-libGLU` — устанавливаем актуальную 32-хбитную версию [WineHQ](https://www.winehq.org) из репозитория
`# sudo apt-get install winetricks samba-winbind` — дополнительно устанавливаем winetriks, что бы иметь возможность конфигурирования [WineHQ](https://www.winehq.org), а так же [демоном](https://ru.wikipedia.org/wiki/%D0%94%D0%B5%D0%BC%D0%BE%D0%BD_(%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B0)) (службой в терминах Windows) winbind
`# winecfg` — Запускаем [WineHQ](https://www.winehq.org) для того что бы убедится что все установилось штатно, а так же можно немного покопаться в настройках
**2.2.** Установка драйверов для ключей [Guardant](https://www.guardant.ru)
`# sudo apt-get install wine-grdwine i586-wine-grdwine` — устанавливаем драйвер как x86, так и x64 для ключей [Guardant](https://www.guardant.ru) из репозитория [ALT Linux](https://alt-linux.ru)
Для работы приложений Windows, защищённых ключами [Guardant](https://www.guardant.ru) под [WineHQ](https://www.winehq.org), необходима библиотека **grdwine.dll.so**. Для этого из комплекта разработчика с включенной библиотекой [с сайта разработчика](https://dev.guardant.ru/pages/viewpage.action?pageId=1278017) для [WineHQ](https://www.winehq.org) — **grdwine**, распространяемый под свободной лицензией GNU Lesser General Public License version 2.1, необходимо скачать с сайта разработчика архив [grdwine-0.5.7-bin.tar.gz](https://download.guardant.ru/support/linux/wine/grdwine-0.5.7-bin.tar.gz) и распаковать его.
**2.3.** Установка и настройка [PlayOnLinux](https://www.playonlinux.com/en/)
Для того что бы меньше возится с [консолью/терминалом](https://habr.com/ru/company/redmadrobot/blog/538446/) и иметь более гибкие возможности настраивать [WineHQ](https://www.winehq.org) в графическом режиме приложение [PlayOnLinux](https://www.playonlinux.com/en/)
`# sudo apt-get update` — снова обновляем заголовки актуального ПО из подключенных репозиториев
`# sudo apt-get install i586-playonlinux` — производим установку приложения [PlayOnLinux](https://www.playonlinux.com/en/)
**2.4.** Настраиваем [PlayOnLinux](https://www.playonlinux.com/en/)
**2.4.1** В [PlayOnLinux](https://www.playonlinux.com/en/) необходимо создать раздел для установки [ГСС-3](https://www.gosstroysmeta.ru/products/download/). Т.к. ПО все еще 32-хбитное, то заводим 32-битную [«бутылку»](https://pingvinus.ru/program/wine) с [WineHQ](https://www.winehq.org) 6-й версии. Для этого заходим в настройки и создаем виртуальный диск.
**Скриншоты настроек п.2.4.1**
**2.4.2** Здесь же, в параметрах [«бутылки»](https://pingvinus.ru/program/wine), устанавливаем необходимые библиотеки, для беспроблемной работы, а именно:
— Microsoft Core Fonts
— msxml3
— msxml6
— riched20
— riched30
— mfc42
— vcrun6
В [PlayOnLinux](https://www.playonlinux.com/en/) в настройках [WineHQ](https://www.winehq.org) нужно выставить ОС Windows 7-10, а так же дополнительно добавить библиотеку riched32. Для riched32 и riched20 выбрать параметр «сперва внутренняя, потом внешняя».
**Скриншоты настроек п.2.4.2**
**2.4.3** Устанавливаем [ГСС-3](https://www.gosstroysmeta.ru/products/download/)
Для чего скачиваем с сайта дистрибутив [по этой ссылке](https://www.gosstroysmeta.ru/products/download/) (на момент написания статьи это версия 3.20.0) и проводим установку через интерфейс [PlayOnLinux](https://www.playonlinux.com/en/), нажав на кнопку «Установка». Установщик программы уже содержит драйвер ключа [Guardant](https://www.guardant.ru), однако если Вы по каким-топричинам забыли или в составе иного ПО такой драйвер будет отсутствивовать то его так же нужно будет установить отдельно, скачав свежую версию [по этой ссылке](https://www.guardant.ru/support/users/drivers/).
**Скриншоты настроек п.2.4.3**
**2.4.4** В конце установки ПО Вам предложат создать ярлыки для запуска приложений. Так же в любой момент можно будет сделать свои собственные ярлыки, используя меню настроек [PlayOnLinux](https://www.playonlinux.com/en/)
**Скриншоты настроек п.2.4.4**
**2.5** Следующий важный шаг: файл **grdwine.dll.so** из п.2.2 переименовываем в **grdwine.dll** через стандартный файловый менеджер Linux копируем в 2 каталога:
> /home/**USERNAME**/PlayOnLinux's virtual drives/**test**/drive\_c/Program Files/ГОССТРОЙСМЕТА-3/
> /home/**USERNAME**/PlayOnLinux's virtual drives/**test**/drive\_c/windows/system32/
Где USERNAME — имя Вашего локального Пользователя (Учетной записи) в [ALT Linux](https://alt-linux.ru), а test — наименование виртуального раздела для устанавливаемого ПО. В случае если Вы при инсталляции изменили путь установки ПО по умолчанию, то Ваши пути к файлам будут отличаться от указанных.
В этот момент необходимо переткнуть флеш-ключ в USB порту, после чего через [PlayOnLinux](https://www.playonlinux.com/en/) или с ярлыка на рабочем столе необходимо запустить grddiag (../drive\_c/windows/system32/grddiag.exe). Если Вы сделали все верно, то диагностическая утилита увидит ключ программы:
2.6 Настройка обновлений [ГСС-3](https://www.gosstroysmeta.ru/products/download/)
Для того что бы ПО обновлялось без проблем необходимо в Настройках обновлений поставить галочку у пункта: «Автоматически загружать все доступные обновления»
### 3. Работа ключа в MS Windows
Вместо тысячи слов. Это один и тот же ключ, один и тот же дистрибутив, который работает и устанавливается как в Windows, так и в Linux
### 4. Заключение
Разработчики российского ПО сейчас активно занимаются адаптацией своих приложений из MS Windows для работы в среде [WINE@Etersoft](https://etersoft.ru/products/wine), но как показывает практика такие версии дистрибутивов так же прекрасно работают в обычном [WineHQ](https://www.winehq.org). Сложно сказать, когда мы увидим [нативные](https://ru.wiktionary.org/wiki/%D0%BD%D0%B0%D1%82%D0%B8%D0%B2%D0%BD%D1%8B%D0%B9) версии таких программ под Linux, но мой опыт, офорленный на Хабре в виде этой и [прошлой](https://habr.com/ru/post/663726/) статей, позволяет говорить о том, что уже сейчас можно настроить удобное рабочее место для офисной работы в Linux [инженеру-сметчику](https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D0%B6%D0%B5%D0%BD%D0%B5%D1%80-%D1%81%D0%BC%D0%B5%D1%82%D1%87%D0%B8%D0%BA)/[инженеру-ПТО](https://tehnavigator.ru/Biblioteka/238.pdf).
**Составление смет ресурсно-индексным методом в продуктах «ГОССТРОЙСМЕТА» с применением ФСНБ-2022** | https://habr.com/ru/post/704686/ | null | ru | null |
# Великолепные стикеры с помощью CSS3
Доброго времени суток!
#### Введение
В своё время было необходимо сделать заметки в форме стикеров для веб-сайта. Как вы понимаете, выбора большого особо не было и мой выбор пал на всеми нам любимый CSS3. С его появлением осуществление задуманного стало возможным без какого-либо велосипедостроения. ~~Итак, моё решение проблемы под катом.~~ На самом деле, мопед не мой. Мне [дали](http://net.tutsplus.com/tutorials/html-css-techniques/create-a-sticky-note-effect-in-5-easy-steps-with-css3-and-html5/) всего-лишь покататься.
Данное решение работает в последних браузерах на движке Webkit (Safari и Chrome), Firefox и Opera. В остальных браузерах (читай, IE) есть шанс получить квадратный стикер жёлтого цвета без тени и анимации.
#### Шаг 1
Давайте начнём с простейшего варианта, который будет работать во всех браузерах. Для того, чтобы сделать стикер, мы будем использовать HTML5 и CSS3, что логично. А начнём мы с обычной HTML разметки, в которой мы обозначим тексты и заголовки наших заметок, которые по сути являются списками.
```
* [Title #1
--------
Content #1](#)
* [Title #1
--------
Content #2](#)
```
Обратите внимание, что каждая заметка является ссылкой, что является достаточно хорошим подходом, т.к. это означает то, что если мы нажмём на нашу заметку, то в случае релевантной ссылке можем попасть на страницу, связанную непосредственно с заметкой.
Например, я записал «купить BMW X6» в воскресенье (тут хочется передать привет [Boomburum](https://habrahabr.ru/users/boomburum/), а по ссылке задал адрес, где найти эту машинку. Хе-хе!
CSS же, чтобы превратить этот списочек в жёлтые стикеры достаточно прост:
```
* {
margin: 0;
padding : 0;
}
body {
font-family: arial, sans-serif;
font-size: 100%;
margin: 3em;
background: #666;
color: #FFF;
}
h2, p {
font-size: 100%;
font-weight: normal;
}
ul, li {
list-style: none;
}
ul {
overflow: hidden;
padding: 3em;
}
ul li a {
text-decoration: none;
color: #000;
background: #FFC;
display: block;
height: 10em;
width: 10em;
padding: 1em;
}
ul li {
margin: 1em;
float: left;
}
```
Данный код настолько тривиален, что нет смысла его комментировать, т.к. мы тут производим стандартные манипуляции. Такие как избавление от пуль в списке, назначение отступов и т.д.
Кстати, вот результат:
Данный вариант будет работать в любом браузере. Даже (**!!!**) в IE6. На этом мы и закончим его поддержку, т.к. нам нужны краски, а не одноцветный прямоугольник. Так ведь?
#### Шаг 2
Пора преукрасить наши стикеры. Давайте добавим к ним тени и зададим текстам заметок шрифт, похожий на рукописный. Для этого мы будем использовать [Google Fonts API](http://code.google.com/apis/webfonts/docs/webfont_loader.html). А использовать мы будем шрифт под именем *Reenie Beanie*. Самый простой способ использовать данный API — работать с [Google Font previewer](http://code.google.com/webfonts/preview#font-family=Reenie+Beanie):
Используя его, мы получаем кусочек HTML кода, который нам нужно вставить в свою страницу, чтобы использовать шрифт. Такой вариант будет поддерживаться во всех современных браузерах:
fonts.googleapis.com/css?family=Reenie+Beanie:regular“
rel = „stylesheet“
type = „text/css“>
Затем нам необходимо сделать отступ от заголовков к заметкам, чтобы наши заметки были читабельными. Познакомить абзацы с новым~~Годом~~ шрифтом. Стоит обратить внимание, что размер шрифта должен быть достаточно крупным, чтобы можно было хорошо разглядеть наш *Reenie Beanie*.
```
ul li h2 {
font-size: 140%;
font-weight: bold;
padding-bottom: 10px;
}
ul li p {
font-family: "Reenie Beanie", arial, sans-serif;
font-size: 180%;
}
```
А теперь давайте зададим тень нашим стикерам. Да так, чтобы во всех (кроме IE) браузрах отображалось:
```
ul li a {
text-decoration: none;
color: #000;
background: #FFC;
display: block;
height: 10em;
width: 10em;
padding: 1em;
-moz-box-shadow: 5px 5px 7px rgba(33, 33, 33, 1); /* для Firefox Грозного */
-webkit-box-shadow: 5px 5px 7px rgba(33, 33, 33, 7); /* да для люда обычного, праведного */
-box-shadow: 5px 5px 7px rgba(33, 33, 33, 7); /* и про Оперушку не забудем */
}
```
Смещение, цвет, ширина, высота — всё, как ~~доктор прописал~~ обычно. Вместе с новым шрифтом и нашими ~~финтифлюшками~~ тенями на стикеры теперь стало смотреть ещё приятнее. Выглядит они теперь вот так:
#### Шаг 3
Теперь я предлагаю вам заняться вещью ещё более увлекательной и интересной. Изменим углу поворота наших стикеров. Как? Используя свойство CSS3: *[transform: rotate](http://www.w3.org/TR/css3-2d-transforms/)*. Вот так:
```
ul li a {
-webkit-transform: rotate(-6deg);
-o-transform: rotate(-6deg);
-moz-transform: rotate(-6deg);
}
```
Отлично. На самом деле, нет. Таким образом мы наклонили все стикеры под одним и тем же углом. Даже открывать пример не хочется. Давайте с вами внесём разнообразия и повернём стикеры в разные углы? Давайте:
```
ul li:nth-child(even) a{
-o-transform:rotate(4deg);
-webkit-transform:rotate(4deg);
-moz-transform:rotate(4deg);
position:relative;
top:5px;
}
ul li:nth-child(3n) a{
-o-transform:rotate(-3deg);
-webkit-transform:rotate(-3deg);
-moz-transform:rotate(-3deg);
position:relative;
top:-5px;
}
ul li:nth-child(5n) a{
-o-transform:rotate(5deg);
-webkit-transform:rotate(5deg);
-moz-transform:rotate(5deg);
position:relative;
top:-10px;
}
```
Теперь же каждая вторая ссылка будет наклонена на 4 градуса вправо, отступы по пятью Каждая третья будет отклонена на 3 градуса влево. И так далее… Пока не закончится фантазия.
#### Шаг 4
Согласитесь, надо внести возможность увеличивать нашу заметку при наведении на неё курсором. ~~Тут мы опять воспользуемся CSS3, что не удивительно.~~ Сказано — сделано:
```
ul li a:hover,ul li a:focus{
-moz-box-shadow:10px 10px 7px rgba(0,0,0,.7);
-webkit-box-shadow: 10px 10px 7px rgba(0,0,0,.7);
box-shadow:10px 10px 7px rgba(0,0,0,.7);
-webkit-transform: scale(1.25);
-moz-transform: scale(1.25);
-o-transform: scale(1.25);
position:relative;
z-index:5;
}
```
Мы добавили такой высокий *z-index* для того, чтобы при наведении наш стикер не ограничивал себя ~~в захвате земель~~ и перекрывал ближние стикеры. Собственно, при наведении мы увидим следующую картину:
#### Шаг 5
Всё-таки надо доделать, чтобы было красиво. Понимаете, чего нам не хваиает? Правильно, анимации. Нужно сделать переходы плавными, а не каменными. ~~Такое ощущение, что ты в каменном веке или же тебе не хватает ЦП.~~ Что же, поехали:
```
ul li a{
text-decoration:none;
color:#000;
background:#ffc;
display:block;
height:10em;
width:10em;
padding:1em;
-moz-box-shadow:5px 5px 7px rgba(33,33,33,1);
-webkit-box-shadow: 5px 5px 7px rgba(33,33,33,.7);
box-shadow: 5px 5px 7px rgba(33,33,33,.7);
-moz-transition: -moz-transform .15s linear;
-o-transition: -o-transform .15s linear;
-webkit-transition:-webkit-transform .15s linear;
}
```
Вот она наша анимация. К сожалению, скриншот не может её передать также, как телефон не может передать запах свежеиспечённой ~~птицы~~ пиццы. ~~Какая жаль!~~
Но ещё бы хотелось разукрасить наши стикеры, а то как-то уж всё монотонно. Каждый второй стикер будет зелёным, каждый третий — синим. А что, неплохо.
```
ul li:nth-child(even) a{
-o-transform: rotate(4deg);
-webkit-transform: rotate(4deg);
-moz-transform: rotate(4deg);
position: relative;
top: 5px;
background: #cfc;
}
ul li:nth-child(3n) a{
-o-transform: rotate(-3deg);
-webkit-transform: rotate(-3deg);
-moz-transform: rotate(-3deg);
position: relative;
top: -5px;
background: #ccf;
}
```
Опять же, анимацию мы на скриншоте увидеть не сможем, но нашу трёхцветную ~~зёбру~~ смесь — без проблем. А вообще, пример вы можете посмотреть [здесь](http://d2o0t5hpnwv4c1.cloudfront.net/771_sticky/step5.html).
#### Заключение
Ну вот и всё на сегодня. Сегодня мы научились создавать красивые анимированные стикеры с помощью CSS3. Ведь красивые, правда?
Пример данного урока можно стянуть [здесь](http://d2o0t5hpnwv4c1.cloudfront.net/771_sticky/stickynotes.zip).
До скорых встреч! | https://habr.com/ru/post/136238/ | null | ru | null |
# Чистая архитектура с Typescript: DDD и слоистая архитектура
Привет, Хабр! В последнее время уделяю много внимание архитектуре и решил поделиться с сообществом переводом статьи [Clean Architecture with Typescript: DDD, Onion](https://bazaglia.com/clean-architecture-with-typescript-ddd-onion/) автора [André Bazaglia](https://bazaglia.com).
Введение
--------
На протяжении более 6 лет моего профессионального опыта, я имел возможность работать в крутых технологических компаниях, которые уделяют много внимания высокой доступности и качеству кода. Мне доводилось иметь дело с критическими ситуациями, когда баги или даже секундные простои системы были недопустимы.
Целью данной статьи является не детальное покрытие сложных тем по DDD и Слоистой архитектуре, а пример реализации этих двух подходов в Typescript. Используемый проект является базовым и может быть доработан и расширен, например с использованием подхода [CQRS](https://ru.wikipedia.org/wiki/CQRS).
Почему DDD?
-----------
Создаваемые программные продукты должны реализовывать поставленные бизнес-требования.
Данный подход упрощает тестирование доменного слоя, что позволяет быть уверенным в том, что все бизнес-требования учтены, и писать долгоживущий, защищенный от ошибок код.
DDD в сочетании со слоистой архитектурой позволяет избегать эффекта домино, когда изменение кода в одном месте приводит к неисчислимому количеству багов в разных местах.
Почему слоистая архитектура?
----------------------------
Этот подход отлично сочетается с DDD, так как вся система строится вокруг доменной модели, которая является центральным кругом на изображении ниже. Внутренние слои не зависят напрямую от внешних и используют их посредством инъекции. Плюсом мы получаем отличную гибкость, так каждый слой имеет свою зону ответственности и входящие данные валидируются каждым слоем в соответствии с его потребностями. А следовательно, внутренние слои всегда получают валидные данные от внешних слоёв. Не говоря уже о тестировании: юнит-тестирование становится более простым с использованием моков зависимостей на основе интерфейсов, что позволяет абстрагироваться от внешних частей системы, таких как базы данных.
В случае Typescript и Javascript, [Инверсия управления (через Инверсию зависимостей)](https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D0%B2%D0%B5%D1%80%D1%81%D0%B8%D1%8F_%D1%83%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F) означает внедрение (передачу) зависимостей через параметры вместо явного импорта. В следующем примере кода мы будем использовать библиотеку [Inversify](https://github.com/inversify/InversifyJS), которая позволяет нам описывать зависимости используя декораторы для того, чтобы создаваемые впоследствии классы могли иметь динамически созданные контейнеры для разрешения зависимостей.
Архитектура
-----------
### Для этого простого приложения...
Мы создадим простое приложение корзины покупок, способное обрабатывать добавление товаров в корзину. Корзина может иметь несколько бизнес-правил, таких как минимальное или максимальное количество для каждого товара.
Давайте погрузимся в глубину слоёв приложения, начнем с самого внутреннего слоя и будем продвигаться наружу последовательно.
### Домен
Доменный слой, по определению является местом обитания бизнес-правил. Он ничего не знает про любые внешние слои, не имеет зависимостей и может быть легко протестирован. Даже если вы измените всё приложение вокруг, домен останется нетронутым, так как он содержит только бизнес-правила, доступные для понимания их назначения каждому читающему этот код. Данный слой должен быть максимально покрыт тестами.
Итак, мы имеем базовый класс Entity, который может содержать определенную логику, общую для всех доменных классов. В данном примере вся общая логика заключается в генерации устойчивого к коллизиям идентификатора, подходящего для горизонтального масштабирования, и все объекты будут использовать данный подход.
```
export abstract class Entity {
protected readonly \_id: string
protected props: T
constructor(props: T, id?: string) {
this.\_id = id ? id : UniqueEntityID()
this.props = props
}
// other common methods here...
}
```
После написания класса Entity можно приступать к созданию нашего центрального доменного класса, расширяющего абстрактный класс Entity.
В этом классе нет ничего очень сложного, но есть некоторые интересные моменты, на которые следует обратить внимание.
Во первых, конструктор является приватным, это означает, что выполнение **new Cart()** вызовет ошибку, такое поведение нам и требуется. В DDD считается хорошей практикой сохранение доменного объекта всегда в валидном состоянии. Вместо непосредственного создания пустого объекта Cart, мы используем [паттерн Фабрика](https://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%B1%D1%80%D0%B8%D1%87%D0%BD%D1%8B%D0%B9_%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)), который возвращает готовый инстанс класса Cart. Для уверенности в том, что процедура создания получила все требуемые атрибуты, может выполняться их валидация. Подобным образом, геттеры и сеттеры используются для взаимодействия с доменом, именно по этой причине внутреннее состояние класса хранится в приватном объекте **props**. Геттеры предоставляют доступ на чтение к атрибутам, которые должны быть публичными. Аналогично, публичные сеттеры и другие методы позволяют изменять домен с постоянной гарантией валидности состояния объекта.
**Подводя итог, можно подчеркнуть важный момент: доменная логика должна быть сфокусирована на поведениях, а не на свойствах.**
```
export class Cart extends Entity {
private constructor({ id, ...data }: ICartProps) {
super(data, id)
}
public static create(props: ICartProps): Cart {
const instance = new Cart(props)
return instance
}
public unmarshal(): UnmarshalledCart {
return {
id: this.id,
products: this.products.map(product => ({
item: product.item.unmarshal(),
quantity: product.quantity
})),
totalPrice: this.totalPrice
}
}
private static validQuantity(quantity: number) {
return quantity >= 1 && quantity <= 1000
}
private setProducts(products: CartItem[]) {
this.props.products = products
}
get id(): string {
return this.\_id
}
get products(): CartItem[] {
return this.props.products
}
get totalPrice(): number {
const cartSum = (acc: number, product: CartItem) => {
return acc + product.item.price \* product.quantity
}
return this.products.reduce(cartSum, 0)
}
public add(item: Item, quantity: number) {
if (!Cart.validQuantity(quantity)) {
throw new ValidationError(
'SKU needs to have a quantity between 1 and 1000'
)
}
const index = this.products.findIndex(
product => product.item.sku === item.sku
)
if (index > -1) {
const product = {
...this.products[index],
quantity: this.products[index].quantity + quantity
}
if (!Cart.validQuantity(product.quantity)) {
throw new ValidationError('SKU exceeded allowed quantity')
}
const products = [
...this.products.slice(0, index),
product,
...this.products.slice(index + 1)
]
return this.setProducts(products)
}
const products = [...this.products, { item, quantity }]
this.setProducts(products)
}
public remove(itemId: string) {
const products = this.products.filter(product => product.item.id !== itemId)
this.setProducts(products)
this.emitCartMutation()
}
public empty() {
this.setProducts([])
}
}
```
В то время, как наш объект класса Cart может быть использован приложением посредством доменных методов, в некоторых случаях, нам может понадобиться «развернуть» его в чистый объект. Например, для сохранения в базу данных или отправки клиенту в виде JSON-объекта. Это может быть реализовано использованием метода **unmarshal()**.
Для повышения гибкости архитектуры, доменный слой также может стать источником доменных событий. Здесь может быть применен подход [Event Sourcing](https://microservices.io/patterns/data/event-sourcing.html), с созданием событий при изменениях доменных сущностей.
### Пользовательские сценарии
Здесь мы будем использовать доменные методы и внедренные с инфраструктурного уровня объекты для сохранения данных.
Мы используем библиотеку **inversify** для реализации подхода Инверсия управления, который внедряет репозиторий из слоя инфраструктуры в данный сценарий, предоставляя нам возможность манипулировать корзиной посредством доменных методов и сохранять изменения в базе данных после этого.
```
import { inject, injectable } from 'inversify'
@injectable()
export class CartService {
@inject(TYPES.CartRepository) private repository: CartRepository
private async _getCart(id: string): Promise {
try {
const cart = await this.repository.getById(id)
return cart
} catch (e) {
const emptyCart = Cart.create({ id, products: [] })
return this.repository.create(emptyCart)
}
}
public getById(id: string): Promise {
return this.repository.getById(id)
}
public async add(cartId: string, item: Item, sku: number): Promise {
const cart = await this.\_getCart(cartId)
cart.add(item, sku)
return this.repository.update(cart)
}
public async remove(cartId: string, itemId: string): Promise {
const cart = await this.\_getCart(cartId)
cart.remove(itemId)
return this.repository.update(cart)
}
}
```
Этот слой отвечает за работу приложения. Изменения кода этого слоя не влияют на доменные сущности или внешние зависимости вроде базы данных.
### Инфраструктура
Несмотря на всю очевидность, инфраструктурный слой реализует взаимодействие со внешними системами, такими как база данных.
Для сохранения данных в БД, я использую подходы Data mapper и Repository.
Маппер может получить исходные данные из БД и преобразовать их в соответствующий доменный объект:
```
import { Cart, CartItem } from 'src/domain/cart'
const getProducts = (products: CartItem[]) => {
return products.map(product => ({
item: product.item,
quantity: product.quantity
}))
}
export class CartMapper {
public static toDomain(raw: any): Cart {
return Cart.create({
id: raw.id,
couponCode: raw.couponCode,
products: getProducts(raw.products || [])
})
}
}
```
Репозиторий сам по себе может зависеть от клиентской библиотеки конкретной БД. Например, от хранилища в оперативной памяти, и использовать эти методы для управления данными:
```
import { injectable, inject } from 'inversify'
import { Cart } from 'src/domain/cart'
import { CartMapper } from '../mappers/cart'
interface ICartRepository {
getById(id: string): Promise
create(cart: Cart): Promise
update(cart: Cart): Promise
}
@injectable()
export class CartRepository implements ICartRepository {
@inject(TYPES.Database) private \_database: MemoryData
async getById(id: string): Promise {
const cart = await this.\_database.cart.getById(id)
if (!cart) {
throw new ResourceNotFound('Cart', { id })
}
return CartMapper.toDomain(cart)
}
async create(cart: Cart): Promise {
const dtoCart = cart.unmarshal()
const inserted = await this.\_database.cart.insert(dtoCart)
return CartMapper.toDomain(inserted)
}
async update(cart: Cart): Promise {
const dtoCart = cart.unmarshal()
const updated = await this.\_database.cart.update(cart.id, dtoCart)
return CartMapper.toDomain(updated)
}
}
```
Заключение
----------
Осталось много пространства для доработок и улучшений. Код был создан для данной наглядной демонстрации и первым улучшением слоистой архитектуры может стать разнесение объявления интерфейса репозитория в доменный слой и его реализации в слой инфраструктуры, что мы сможем обсудить в следующий раз.
Исходный код доступен на [гитхабе](https://github.com/bazaglia/shopping-cart). | https://habr.com/ru/post/486734/ | null | ru | null |
# Вычислительные Графы, Спекулятивные Замки и Арены для Задач в Intel® Threading Building Blocks
Данный пост является переводом статьи «Flow Graphs, Speculative Locks, and Task Arenas in Intel Threading Building Blocks» из Parallel Universe Magazine, выпуск 18, 2014. Если вас интересует библиотека Intel TBB в частности, и интересные современные концепции параллельного программирования в общем, то добро пожаловать под кат.
#### Введение
Библиотека Intel Threading Building Blocks (Intel TBB) предоставляет С++ программистам решение для добавления параллелизма в их приложения и библиотеки. Широко известное преимущество библиотеки Intel TBB в том, что она делает легкодоступной для разработчиков масштабируемость и мощь параллельного выполнения их приложений, если их алгоритмы основаны на циклах или задачах. Общий обзор библиотеки можно увидеть под спойлером.
**О библиотеке**Библиотека включает в себя общие параллельные алгоритмы, планировщик и балансировщик задач, потокобезопасные контейнеры, диспетчер памяти, примитивы синхронизации и прочее (Рис. 1). Используя базовые шаблоны параллельного программирования совместно с этими строительными блоками, разработчики делают параллельные приложения, которые абстрагируются от проблем реализации механизма многопоточности на какой-то конкретной платформе, при этом получая производительность, которая масштабируется с увеличением числа ядер.
Рис 1: “Строительные блоки” Intel Threading Building Blocks
Книга “Structured parallel programming” [1] описывает ряд полезных параллельных шаблонов, которые хорошо ложатся на алгоритмы Intel TBB:
* *parallel\_for*: map, stencil (многомерная таблица данных)
* *parallel\_reduce, parallel\_scan*: reduce (редукция), scan (вычисление частичных редукций)
* *parallel\_do*: workpile (многомерная таблица данных с неизвестным числом элементов на начало выполнения)
* *parallel\_pipeline*: pipeline (конвейер)
* *parallel\_invoke, task\_group*: шаблоны fork-join
* *flow\_graph*: шаблоны работы с вычислительным графом
Библиотека Intel TBB может быть использована с любым С++ компилятором. Она также поддерживает стандарт С++11, например, лямбда выражения, что упрощает написание и читаемость кода, так как отпадает необходимость писать служебные функторные классы. Различные компоненты библиотеки могут быть использованы независимо и даже сочетаться с другими технологиями параллельного программирования.
Версия Intel TBB 4.2 внесла новый функционал, который включает в себя поддержку новейших функций архитектуры, таких как технология Intel Transactional Synchronization Extensions (Intel TSX) и поддержка сопроцессора Intel Xeon Phi на Windows\*. Также появилась поддержка приложений для Windows Store\* and Android\* [2, 3]. Кроме того, были улучшены текущие компоненты (см. документацию). Intel TBB 4.2 доступен как отдельно, так и в составе таких продуктов, как Intel INDE, Intel Cluster Studio XE, Intel Parallel Studio XE, Intel C++ Studio XE, Intel Composer XE and Intel C++ Composer XE.
Версия библиотеки с открытым исходным кодом поддерживает больше архитектур, компиляторов и операционных систем, благодаря вкладу нашего сообщества. Библиотека может работать с операционной системой Solaris\* и компилятором Oracle\* C++ compiler for Intel Architecture и компилятором C++ для SPARC\*-совместимых архитектур, IBM\* Blue Gene\* суперкомпьютеров и PowerPC\*-совместимых архитектур. Она также работает с операционными системами Android\*, Windows Phone\* 8 и Windows RT\* для ARM\*-совместимых архитектур, FreeBSD\*, Robot\* и многих других платформ, где поддерживаются атомарные операции, встроенные в компилятор GCC\*. Эта широкая кроссплатформенность означает, что приложение, однажды написанное с использованием библиотеки Intel TBB, может быть перенесено на многие другие операционные системы или архитектуры без переписывания основных алгоритмов.
Далее, мы сфокусируемся на нескольких специфичных частях библиотеки. Сначала будет обзор вычислительного графа (*flow graph*), который доступен, начиная с версии Intel TBB 4.0. Затем будет рассказано о двух компонентах библиотеки, которые были впервые выпущены в версии Intel TBB 4.2. Это спекулятивные замки (*speculative locks*), которые используют преимущества технологии Intel Transactional Synchronization Extensions (Intel TSX) и управляемые пользователем арены для задач (*user-managed task arenas*), которые обеспечивают расширенный контроль и управление уровнем параллелизма и изоляции задач.
#### Вычислительные графы
Хотя библиотека Intel TBB хорошо известна распараллеливанием циклов, интерфейс вычислительного графа [4] расширяет её возможности для быстрой и эффективной реализации алгоритмов, базируемых на графах зависимостей по данным и/или исполнению, помогая разработчикам использовать параллелизм в их приложениях на более высоком уровне.
Для примера рассмотрим простое приложение, которое последовательно выполняет четыре функции, как показано на Рис. 2(a). Подход распараллеливания по циклам подразумевает, что разработчик может рассмотреть каждую из этих функций на предмет распараллеливания с использованием таких алгоритмов, как parallel\_for и parallel\_reduce. Иногда этого может быть достаточно, но в других случаях этого может быть недостаточно. Например, на Рис. 2(b) показано, что удалось распараллелить по циклам функции B и D. Время выполнения в этом случае сократится, но что делать, если полученное увеличение производительности всё еще не достаточно?
Рис. 2: Простой пример разных форм параллелизма
Иногда на вызов функций накладываются чрезмерные ограничения, как то: порядок вызова функций должен быть определенный, строго упорядоченный, вызовы один за другим, даже в случае не полных, а частичных зависимостей между функциями. На Рис. 2(а) функции расписаны разработчиком в таком порядке, чтобы функция выполнялась только после того, как все входные значения получены в процессе предыдущего выполнения. Но что делать, если функции B и C зависят от данных, вычисленных в функции A, а функция С не зависит от данных функции B? Рис. 2(с) показывает реализацию этого примера через граф и распараллеливание циклов. В этой реализации использовано распараллеливание на уровне циклов и полное упорядочивание заменено частичным, которое позволяет функциям B и C выполняться одновременно.
Интерфейс Intel TBB flow graph interface позволяет разработчикам легко выразить параллелизм на уровне графов. Он предоставляет поддержку для различных типов графов, которые могут быть найдены во многих областях, таких как обработка мультимедиа информации, игры, финансовые и высокопроизводительные вычисления, а также вычисления в здравоохранении. Этот интерфейс полностью поддерживается в библиотеке и доступен, начиная с Intel TBB 4.0.
При использовании Intel TBB flow graph вычисления представляются узлами, а каналы коммуникаций между этими узлами представляются ребрами. Пользователь использует ребра, чтобы задать зависимости, которые должны учитываться узлами при постановке в очередь на выполнение, предоставляя планировщику задач Intel TBB реализовать параллелизм на уровне топологии графа. Когда узел в графе получает сообщение, задача выполнить функтор над этим сообщением ставится в очередь на выполнение планировщиком Intel TBB.
Интерфейс flow graph поддерживает несколько различных типов узлов (Рис. 3): функциональные узлы (Functional nodes), которые выполняют пользовательские функции, буферные узлы (Buffering nodes), которые могут быть использованы для упорядочения и буферизации сообщений так, как они должны проходить через граф, узлы агрегации и де-агрегации (Aggregation / Deaggregation nodes), которые соединяют или разъединяют сообщения, а также другие полезные узлы. Пользователи соединяют объекты этих узлов ребрами, для того чтобы указать зависимости между ними, и предоставляют объекты, которые выполняют работу в этих узлах.
Рис. 3: Типы узлов (nodes), поддерживаемых интерфейсом flow graph
Рассмотрим исходный код для простого flow graph приложения “Hello World”. Этот пример очень простой и не содержит какого-либо параллелизма, но демонстрирует синтаксис данного интерфейса. В этом примере при помощи лямбда выражений создается два узла: *hello* и *world*, которые печатают, соответственно “Hello” и “World”. Каждый узел типа *continue\_node* является функциональным узлом с типом, предусмотренным интерфейсом. Вызов *make\_edge* создает ребро между узлами *hello* и *world*. Когда бы ни завершилась задача, запущенная узлом *hello*, она пошлет сообщение узлу *world*, заставив запустить задачу на выполнение его лямбда выражения.
```
#include "tbb/flow_graph.h"
#include
using namespace std;
using namespace tbb::flow;
int main() {
graph g;
continue\_node< continue\_msg> hello( g,
[]( const continue\_msg &) {
cout << "Hello";
}
);
continue\_node< continue\_msg> world( g,
[]( const continue\_msg &) {
cout << " World\n";
}
);
make\_edge(hello, world);
hello.try\_put(continue\_msg());
g.wait\_for\_all();
return 0;
}
```
В вышеизложенном коде вызов *hello.try\_put(continue\_msg())* отправляет сообщение узлу *hello*, заставляя его вызвать задачу на выполнение тела объекта. Когда задача выполнена, она отсылает сообщение узлу *world*. Только когда все задачи, запущенные узлами, закончены, выполняется возврат из функции *g.wait\_for\_all().*
Интерфейс Intel TBB flow graph позволяет программировать очень сложные графы, включающие в себя тысячи узлов, ребер, циклов и прочих элементов. Рис. 4 показывает визуальное представление двух графов реализации Разложения Холецкого, которые используют алгоритм, похожий на тот, который можно найти в [5]. На Рис. 4(а) каждый вызов функций библиотеки Intel Math Kernel Library (Intel MKL) *dpotf2m*, *dtrsm*, *dgemm* и *dsyrk* — это отдельный узел в графе. В этом случае граф огромен, с множеством узлов на каждый блок матрицы, но он может быть легко реализован, модифицируя изначальные последовательные вложенные циклы Разложения Холецкого путем замены вызовов функций на создание узлов и ребер. В этом графе ребра использованы для указания связей зависимостей; каждый узел ждет, пока выполнятся все узлы, от которых он зависит. Легко видеть, как реализуется распараллеливание в этом графе.
**Рис. 4: Две параллельные реализации Разложения Холецкого на базе интерфейсов flow graph**
Рис. 4(a) Используя направленный ациклический граф
Рис. 4(b) Используя компактный граф зависимостей по данным
Рис. 4(b) показывает альтернативную версию, которую тоже можно реализовать, используя интерфейс *flow graph*. В этой маленькой, более компактной версии графа, только удин узел, который отвечает за вызовы всех необходимых функций библиотеки Intel MKL. В этой реализации блоки передаются как сообщения между узлами в графе. Когда узел принимает набор блоков определенного типа, он вызывает задачу, которая обрабатывает эти блоки, и затем пересылает новый сгенерированный блок в другие узлы. Распараллеливание в таком графе будет реализовано из-за возможности библиотеки выполнять одновременно много экземпляров объектов каждого узла графа.
Хотя детали реализации, рассмотренные на Рис. 4, выходят за рамки этой статьи, данный пример демонстрирует, что интерфейс Intel TBB flow graph – это мощный и гибкий уровень абстракции. Он может быть использован для создания больших направленных ациклических графов, например, таких, как на Рис 4(а), где разработчик создает выделенный узел для каждого вызова библиотеки Intel MKL. С другой стороны, с помощью интерфейса Intel TBB flow graph можно создать компактный граф зависимостей по данным, который включает в себя циклы и условное выполнение, как показано на Рис. 4(b).
Больше информации об интерфейсах flow graph можно найти в справочном руководстве Intel TBB.
В следующей половине статьи мы рассмотрим спекулятивные замки (speculative locks), которые используют преимущества технологии Intel Transactional Synchronization Extensions (Intel TSX) и управляемые пользователем арены для задач (user-managed task arenas), которые обеспечивают расширенный контроль и управление уровнем параллелизма и изоляции задач.
Продолжение следует…
**Библиография**[1] Michael McCool, Arch Robison, James Reinders “Structured Parallel Programming” [parallelbook.com](http://parallelbook.com/)
[2] Vladimir Polin, “Android\* Tutorial: Writing a Multithreaded Application using Intel Threading Building Blocks”. [software.intel.com/en-us/android/articles/android-tutorial-writing-a-multithreaded-application-using-intel-threading-building-blocks](http://software.intel.com/en-us/android/articles/android-tutorial-writing-a-multithreaded-application-using-intel-threading-building-blocks)
[3] Vladimir Polin, “Windows\* 8 Tutorial: Writing a Multithreaded Application for the Windows Store\* using Intel Threading Building Blocks”. [software.intel.com/en-us/blogs/2013/01/14/windows-8-tutorial-writing-a-multithreaded-application-for-the-windows-store-using](http://software.intel.com/en-us/blogs/2013/01/14/windows-8-tutorial-writing-a-multithreaded-application-for-the-windows-store-using)
[4] Michael J. Voss, “The Intel Threading Building Blocks Flow Graph”,
Dr. Dobb’s, October 2011, [www.drdobbs.com/tools/the-intel-threading-building-blocks-flow/231900177](http://www.drdobbs.com/tools/the-intel-threading-building-blocks-flow/231900177).
[5] Aparna Chandramowlishwaran, Kathleen Knobe, and Richard Vuduc, “Performance
Evaluation of Concurrent Collections on High-Performance Multicore Computing Systems”,
2010 Symposium on Parallel & Distributed Processing (IPDPS), April 2010. | https://habr.com/ru/post/228433/ | null | ru | null |
# Pixel Bender. Спецификация языка в контексте программирования под Flash Player
 Эта статья является вольным переводом [официальной документации](http://www.adobe.com/devnet/pixelbender/pdfs/pixelbender_reference.pdf) по языку Pixel Bender от корпорации Adobe. Хочу сразу заметить, что это перевод именно Pixel Bender Language Reference, а не Pixel Bender Developer's Guide. Как подсказывает Гугл, данная тема еще не всплывала в Рунете и поэтому мне хотелось бы исправить столь досадное упущение)) В переводе были намеренно опущены вопросы программирования под Adobe Photoshop и Adobe AfterEffects, т.к. меня интересовало только написание фильтров под Flash Player.
Pixel Bender является высокопроизводительной графической технологией программирования, предназначенной для обработки изображений.
Pixel Bender kernel — это C-подобный язык с расширениями для обработки изображений. Он основан на GLSL, который, в свою очередь, основан на С. Основы синтаксиса языка должны быть знакомы любому C-программисту.
Основной единицей обработки изображений в Pixel Bender, является ядро (*kernel*) (**Прим. пер.:** Я не знаю как точнее перевести это слово, поэтому доверился Гуглу ;)). Каждое программа на Pixel Bender'е определяет одно ядро. Ядро является объектом, который содержит результат обработки одного пиксела функцией с произвольным числом аргументов, которые могут быть получены от одного или нескольких исходных изображений.
* Программа на языке Pixel Bender определяет именованный объект ядра, указав функцию *evaluatePixel()* которая выполняется над каждым пикселом исходного изображения. Каждое ядро должно содержать определение этой функции.
* Ядро может принимать любое число аргументов произвольных типов. Оно может определять внутри себя параметры и переменные, которые будут использоваться для выполнения различных операций. Pixel Bender является стоготипизированным языком.
* Pixel Bender содержит много встроенных функций для работы с пикселами.
#### Использование фильтров, написанных на Pixel Bender
Adobe предоставляет Pixel Bender Toolkit IDE — интегрированную среду разработки для написания программ на языке Pixel Bender. Работа с Pixel Bender Toolkit IDE описана в Pixel Bender Developer’s Guide (**Прим. пер.:** IDE халявная. Взять версию под Windows можно [отсюда](http://www.adobe.com/go/pixelbender_toolkit_zip)).
Во время разработки, вы можете запускать программы в Pixel Bender Toolkit IDE, которая предоставляет для этого удобный интерфейс. Для получения информации о Pixel Bender Toolkit IDE, см. Pixel Bender Developer’s Guide.
Для запуска фильтров во Flash Player'е вы должны сохранять ваши файлы с расширением .pbj.
Клиентское приложение может по-своему организовывать доступ к параметрам запуска и работы фильтра:
* Клиентское приложение обычно использует атрибут *name*, указанный в ядре, для обращения к данному фильтру.
* Можно указать строку с описанием работы фильтра, которую клиентское приложение будет использовать в качестве подсказки.
* При определении параметра необходимо указать метаданные (например, минимальное, максимальное значения и значение по умолчанию), которые помогают разработчику выбрать и настроить соответствующие элементы пользовательского интерфейса.
#### Директивы препроцессора
Доступными для использования являются следующие директивы препроцессора (аналогичные директивам препроцессора в языке С):
#if
#ifdef
#defined
#endif
#elif
#define
Поскольку Flash Player работает на широком спектре оборудования, только часть языка Pixel Bender доступна для использования в Flash Player. Далее приведен перечень ограничений, накладываемых Flash Player'ом на использование языка Pixel Bender:
* Flash Player всегда работает с объектом размером 1х1 пиксел. Функция *pixelSize()* всегда возвращает (1.0, 1.0), а *pixelAspectRatio()* всегда возвращает 1.0.
* Оператор условного перехода (?:) может быть использован только для выбора между двумя константами или переменными.
* Изображения в Pixel Bender'е имеют 32 бита на канал, но графика в Flash Player 10 имеет только 8 бит на канал. Когда фильтр работает в Adobe Flash Player, данные исходного изображения преобразуются сначала в 32 бита на канал, а затем преобразуются в 8 бит на канал, когда фильтр завершает выполнение.
* Для изменения хода выполнения программы можно использовать только операторы if и else.
* Ниже приводится перечень неподдерживаемых возможностей языка:
1. Функции для работы с регионами.
2. Пользовательские функции и библиотеки.
3. Зависимые значения.
4. Массивы.
5. Язык описания графов (**Прим. пер.:** в оригинале — The Pixel Bender graph language).
#### Синтаксис ядра
В каждой программе, написанной на Pixel Bender задается один блок кода, содержащий набор метаданных, заключенных в угловые скобки, и другой блок кода, описывающий ядро, набор переменных и выполняемые операции, заключенный в фигурные скобки.
`kernel name
<
kernel metadata pairs
>
{
kernel members
}`
Каждое ядро должно начинаться с указания версии языка, на которой пишется код.
Первая часть ядра определяет блок метаданных, состоящий из группы пар имя-значение, заключенный в угловые скобки:
`<
name1 : value1;
name2 : value2;
...
>;`
Следующие значения метаданных являются предопределенными:
*namespace* — Обязательно. Пространство имен, в котором определено ядро.
*vendor* — Обязательно. Издатель.
*version* — Обязательно. Целое число, номер версии реализации этого ядра. Это не тоже самое, что languageVersion (!).
*description* — Необязательно. Описание работы фильтра.
Например:
`<
namespace : "Pixel Bender IDE";
vendor : "Adobe";
version : 1;
description: "A sample filter";
>`
Вторая часть определения ядра представляет собой набор переменных и функций, заключенных в фигурные скобки. Ядро должно содержать по крайней мере определение функции *evaluatePixel()*, а все остальное является необязательным.
`{
[declarations]
[support functions]
void evaluatePixel()
{
statements
}
}`
Объявление переменных обычно содержат в себе объявление пикселов входного и выходного изображения. Также могут быть включены параметры и константы, которые будут использоваться в функциях.
Основная функция, *evaluatePixel()*, применяется для ввода изображений или изображения, над которым выполняется преобразование, результатом которого является один пиксел.
До определения функции *evaluatePixel()* могут быть (необязательно) описаны:
1. **Параметры:**
`parameter type name
<
name1 : value1;
name2 : value2;
...
>`
Параметры задаются только для чтения, в пределах функции ядра. Параметры могут быть любого (доступного для использования в рамках Flash Player) типа, кроме изображений.
2. **Константы:**
`const type name=compile-time_expression;`
Значения констант определяется во время компиляции.
3. **input:**
`input type name;`
Изображение, используемое в качестве аргумента функции *evaluatePixel()*. Его тип должен быть image1, image2, image3, или image4.
4. **output:**
`output type name;`
Набор пикселов, полученный в результате выполнения функции *evaluatePixel()*. Его тип должен быть pixel1, pixel2, pixel3, или pixel4.
#### Параметры метаданных
Параметры могут включать данные, которые описывают этот параметр или накладывают ограничения на его использование. Эти данные будут доступны внутри клиентских приложений после компиляции, и также помогают программисту решить, каким образом спроектировать пользовательский интерфейс, который бы позволял пользователям установить значение параметра.
Значения данных заключаются в угловые скобки, следующие за объявлением параметра.
`parameter type name
<
name1 : value1;
name2 : value2;
...
>`
Имена являются строками. Значения — константами любого допустимого типа Pixel Bender. Для типов int, float и bool определение типа происходит автоматически. Для других типов необъодимо определить константное значение допустимого типа (например: float2(1.0, -1.0 )) или строку ограниченную двойными кавычками. Например:
`parameter int angle
<
minValue : 0;
maxValue : 360;
defaultValue : 30;
description : "measured in degrees";
>;`
Этот параметр накладывает ограничения на возможные значения:
*minValue* — минимально допустимое значение
*maxValue* — максимально допустимое значение
*defaultValue* — значение по умолчанию
*description* — описание параметра, которое можно использовать в клиентском приложении в качестве подсказки.
#### Определение функции ядра
Определение функции ядра должно соответствовать этим условиям:
Все, кроме *evaluatePixel()*, является необязательным.
Синтаксис функции:
`void evaluatePixel()
{
statements
}`
#### Типы данных языка Pixel Bender
Pixel Bender является строготипизированным языком. Нет автоматических преобразований типов, за одним исключением: между векторными типами данных с плавающей точкой и типами данных матриц. Есть несколько типов данных, каждый из которых определен в пределах определенного набора операторов и собственных функций.
Pixel Bender поддерживает следующие базовые типы данных:
bool — логический тип данных
int — целое число
float — число с плавающей точкой
pixel1 — определяет значение одного канала изображения. Цифра «1» отличает данный тип данных от аналогичных ему, но определяющих значения нескольких каналов изображения. Паременная данного типа представлена числом с плавающей точкой и занимает 32 бита памяти.
Все эти типы данных могут участвовать в числовых операциях.
#### Преобразования между скалярными типами данных
Типы данных bool, int, и float могут быть преобразованы из одного в другой с помощью обычных правил в С-стиле:
*type(expression)*
Например:
`int a = int(myfloat)`
Тип данных pixel1 может быть взаимозаменяемым с типом данных float.
**Примечание:**
Тип данных int занимает 16 бит памяти (без учета знака), но его реализация может занимать и более 16 бит памяти. Можно совершать преобразования между типами int и float. Когда результат преобразования из типа int в тип float не может быть представлен как тип int, значение переменной становится неопределенным (undefined).
#### Векторные типы данных
Pixel Bender поддерживает 2-х, 3-х и 4-х элементные аналоги для каждого скалярного типа данных:
float2 bool2 int2 pixel2
float3 bool3 int3 pixel3
float4 bool4 int4 pixel4
Инициализация любого типа (включая пиксельный) представлена общей формой:
*vectorType(element1 [, element2...])*
Например:
`float3(0.5, 0.6, 0.7)`
Есть также сокращенный вариант записи (следующие выражения эквивалентны):
`float3(0.3);
float3(0.3, 0.3, 0.3);`
Вы можете получить доступ к значению векторной переменной по индексу или имени по следующим правилам:
1. С помощью оператора индекса, как к элементу массива:
vectorValue[index]
2. Используя точечную нотацию для доступа к элементам в этой последовательности:
r, g, b, a
x, y, z, w
s, t, p, q
Каждому из этих элементов соответсвует индекс от 0 до 3.
Например, чтобы получить значение первого элемента вектора myVectorValue, вы можете использовать любой из следующих вариантов записи:
myVectorValue[0]
myVectorValue.r
myVectorValue.x
myVectorValue.s
#### Выбор и переопределение значений элементов
Pixel Bender поддерживает свиззлинг для выбора и переопределения порядка следования элементов вектора. Для вектора с n-количеством элементов значения могут быть указаны следом за оператором точки. Соответствующие значения элементов вектора формируют новый результат с таким количеством элементов, как и у присваиваемой переменной. Этот синтаксис можно использовать для изменнения порядка следования, для удаления или повторения элементов вектора. Например:
`float4 vec4;
float3 no_alpha = vec4.rgb; // исключен последний элемент вектора vec4
float3 no_r = vec4.gba; // исключен первый элемент вектора vec4
float4 reversed = vec4.abgr; // изменен порядок следования элементов
float4 all_red = vec4.rrrr; // повторение значения элемента
float4 all_x = vec4.xxxx; // аналогично предыдущему`
Указатели из отдельных последовательностей не могут быть объединены:
`float4 vec4;
float3 no_alpha = vec4.rgz; // Ошибка!`
Указатели индексов также могут быть применены и в левой части выражения присваивания. В этом случае индексы не могут повторяться. Эта возможность используется для записи маскировки (**Прим. пер.:** в оригинале — write-masking). С правой стороны выражения присваивания должно быть правильное количество аргументов:
float3 vec3;
float2 vec2;
vec3.xy = vec2; // устанавливает значения элементов вектора vec2 элементам вектора vec3с индексами 0 и 1
vec3.xz = vec2; // устанавливает значения элементов вектора vec2 элементам вектора vec3с индексами 0 и 2
Взаимодействие:
Свиззлинг и запись маскировки могут быть использованы одновременно по обе стороны выражения присваивания:
`vec3.xz = vec4.wy;`
Существует вероятность появления сложностей между свиззлингом и операцией присваивания. Рассмотрим следующий пример:
`g.yz *= g.yy;`
Упрощенный вариант этой записи можно представить в следующем виде:
`g.y *= g.y;
g.z *= g.y;`
Проблема в том, что значение g.y во второй строке было изменено. Правильным решением была бы следующая запись:
`float2 temp = g.yz * g.yy;
g.yz = temp;`
#### Преобразования между векторными типами данных
Преобразования между векторными типами данных допустимы при условии, что размеры операндов присваивания равны. Само преобразование аналогично преобразованию между скалярными типами данных:
type(expression)
Например:
`float3 fvec3;
int3 ivec3;
fvec3 = float3(ivec3);`
#### Типы матриц
Есть следующие виды матриц:
float2x2
float3x3
float4x4
Создание матриц с помощью конструктора подразумевает использование векторов типа float для указания значений матриц, или указания значений скалярных переменных типа float для каждого элемента матрицы в порядке следования «столбец-ряд» или смеси из векторов и скалярных переменных типа float:
float2x2( float2, float2 )
float2x2( float, float,
float, float )
float3x3( float3, float3, float3 )
float3x3( float, float, float,
float, float, float,
float, float, float )
float4x4( float4, float4, float4, float4 )
float4x4( float, float, float, float,
float, float, float, float,
float, float, float, float,
float, float, float, float )
Вы также можете инициализировать матрицу одной скалярной переменной типа float, которая будет определять значения элементов матрицы на главной диагонали. Все остальные значения будут установлены в ноль:
float2x2( float )
float3x3( float )
float4x4( float )
Для получения доступа к значениям элементов матрицы используйте следующий синтаксис:
*matrix[ столбец ][ ряд ]*
Если опустить указание ряда, то выбирается целиком один столбец и возвращается переменная векторного типа подходящей размерности:
*matrix[ столбец ]*
#### Другие типы данных
**Типы данных изображений.**
Pixel Bender поддерживает также переменные типа image. Они представлены следующими типами данных:
image1
image2
image3
image4
Переменные данных типов не могут быть созданны или использованны в выражениях. Однако они могут быть переданы в качестве аргументов во встроенные функции языка.
**Тип данных void.**
Функции, которые не возвращают значений должны быть определены с типом void.
#### Операторы
Pixel Bender определяет следующие типы операторов для арифметических операций над скалярными типами данных. Здесь они указаны в порядке приоритета выполнения. Скобки могут быть использованы для изменения этого порядка:
. Выбор элемента переменной
++ — Постфиксные операторы инкремента и декремента
++ — Префиксные операторы инкремента и декремента
— ! Унарный оператор отрицания, логическое «НЕ»
\* / Умножение, деление
+ — Сложение, вычитание
< > <= >= Сравнения
== != Равенство
&& Логическое «И»
^^ Логическое «ИСКЛЮЧАЮЩЕЕ ИЛИ»
|| Логическое «ИЛИ»
= += -= \*= /= Группировка операторов
?: Краткая запись операторов ветвления. Данный оператор может быть использован только для выбора между двумя переменными или константами (с правой стороны), но не выражений.
#### Операции над типами данных с несколькими элементами
Стандартные арифметические операторы (+, -, \*, /) могут быть использованы как для операций над скалярными, так и над векторными и матричными типами данных. Бинарный оператор может быть применен к двум векторным операндам только в том случае, если они имеют одинаковый размер. В этом случае операция выполняется для каждого элемента вектора. Например:
float3 x, y, z;
z = x + y;
Эта запись эквивалентна следующей:
z[ 0 ] = x[ 0 ] + y[ 0 ];
z[ 1 ] = x[ 1 ] + y[ 1 ];
z[ 2 ] = x[ 2 ] + y[ 2 ];
Группировка скалярных и векторных паременных также допустима. Например:
float3 x, y;
float w;
x = y \* w;
Эта запись эквивалентна следующей:
x[ 0 ] = y[ 0 ] \* w;
x[ 1 ] = y[ 1 ] \* w;
x[ 2 ] = y[ 2 ] \* w;
Важным исключением из этого правила является перемножение матриц между собой и матриц с векторными переменными. Перемножение осуществляется по правилам линейной алгербы (а не покомпонентно):
float2x2 \* float2x2 Перемножние матриц по правилам линейной алгебры
float3x3 \* float3x3
float4x4 \* float4x4
float2x2 \* float2 Перемножение столбцов на вектор
float3x3 \* float3
float4x4 \* float4
float2 \* float2x2 Перемножение рядов на вектор
float3 \* float3x3
float4 \* float4x4
#### Встроенные функции языка Pixel Bender
**Математические функции:**
Как и арифметические операторы, математические функции могут выполняться над векторными типами данных. В этом случае они работают покомпонентно. Если не определено иное, то все углы указаны в радианах.
float radians( float degrees ) Преобразование градусов в радианы
float2 radians( float2 degrees )
float3 radians( float3 degrees )
float4 radians( float4 degrees )
float degrees( float radians ) Преобразование радианов в градусы
float2 degrees ( float2 radians )
float3 degrees ( float3 radians )
float4 degrees ( float4 radians )
float sin( float radians ) Возвращает синус аргумента
float2 sin( float2 radians )
float3 sin( float3 radians )
float4 sin( float4 radians )
float cos( float radians ) Возвращает косинус аргумента
float2 cos( float2 radians )
float3 cos( float3 radians )
float4 cos( float4 radians )
float tan( float radians ) Возвращает тангенс аргумента. Если x==pi/2.0 возвращается *undefined*
float2 tan( float2 radians )
float3 tan( float3 radians )
float4 tan( float4 radians )
float asin( float x ) Возвращается арксинус аргумента. Возвращаемое значение находится в диапазоне [-pi/2..pi/2]
float2 asin( float2 x )
float3 asin( float3 x )
float4 asin( float4 x )
float acos( float x ) Возвращает арккосинус аргумента. Возвращаемое значение находится в диапазоне [0..pi]
float2 acos( float2 x )
float3 acos( float3 x )
float4 acos( float4 x )
float atan( float y\_over\_x ) Возвращает арктангенс аргумента. Возвращаемое значение находится в диапазоне [-pi/2..pi/2]
float2 atan( float2 y\_over\_x)
float3 atan( float3 y\_over\_x)
float4 atan( float4 y\_over\_x)
float atan( float y, float x ) Возвращает арктангенс выражения y / x. Возвращаемое значение находится в диапазоне [-pi..pi]
float2 atan( float2 y, float2 x )
float3 atan( float3 y, float3 x )
float4 atan( float4 y, float4 x )
float pow( float x, float y ) Возвращает x в степени y и *undefined* если х < 0
float2 pow ( float2 x, float2 y )
float3 pow ( float3 x, float3 y )
float4 pow ( float4 x, float4 y )
float exp( float x ) Возвращает e в степени х (**Прим. пер.:** не помню как называется эта величина:))
float2 exp( float2 x )
float3 exp( float3 x )
float4 exp( float4 x )
float exp2( float x ) Возвращает 2 в степени х
float2 exp2( float2 x )
float3 exp2( float3 x )
float4 exp2( float4 x )
float log( float x ) Возвращает натуральный логарифм числа х
float2 log( float2 x )
float3 log( float3 x )
float4 log( float4 x )
float log2( float x ) Возвращает натуральный логарифм числа х с основанием 2
float2 log2( float2 x )
float3 log2( float3 x )
float4 log2( float4 x )
float sqrt( float x ) Возвращает положительный квадратный корень числа х и *undefined* если х < 0
float2 sqrt( float2 x )
float3 sqrt( float3 x )
float4 sqrt( float4 x )
float inverseSqrt( float x ) Возвращает обратное положительному квадратному корню от числа х и *undefined* если х < 0
float2 inverseSqrt( float2 x )
float3 inverseSqrt( float3 x )
float4 inverseSqrt( float4 x )
float abs( float x ) Если x >= 0, возвращает x, иначе возвращает -x
float2 abs( float2 x )
float3 abs( float3 x )
float4 abs( float4 x )
float sign( float x ) Если x < 0, возвращает -1
float2 sign( float2 x ) Если x == 0, возвращает 0
float3 sign( float3 x ) Если x > 0, возвращает 1
float4 sign( float4 x )
float floor( float x ) Округляет х в меньшую сторону (возвращает целое число)
float2 floor( float2 x )
float3 floor( float3 x )
float4 floor( float4 x )
float ceil( float x ) Округляет х в большую сторону (возвращает целое число)
float2 ceil( float2 x )
float3 ceil( float3 x )
float4 ceil( float4 x )
float fract( float x ) Возвращает x – floor(x)
float2 fract( float2 x )
float3 fract( float3 x )
float4 fract( float4 x )
float mod( float x, float y ) Возвращает x – y \* floor(x/y)
float2 mod( float2 x, float2 y )
float3 mod( float3 x, float3 y )
float4 mod( float4 x, float4 y )
float min( float x, float y ) Если х < y возвращает х, иначе возвращает у
float2 min( float2 x, float2 y )
float3 min( float3 x, float3 y )
float4 min( float4 x, float4 y )
float max( float x, float y ) Если х > у, возвращает х, иначе возвращает у
float2 max( float2 x, float2 y )
float3 max( float3 x, float3 y )
float4 max( float4 x, float4 y )
float step( float x, float y ) Если у < х, возвращает 0.0, иначе возвращает 1.0
float2 step( float2 x, float2 y )
float3 step( float3 x, float3 y )
float4 step( float4 x, float4 y )
float clamp(float x, float minval, float maxval) Если x < minval, возвращает minval. Если x > maxval, возвращает maxval. Иначе возвращает x.
float2 clamp(float2 x, float2 minval, float2 maxval)
float3 clamp(float3 x, float3 minval, float3 maxval)
float4 clamp(float4 x, float4 minval, float4 maxval)
float mix(float x, float y, float a) Возвращает x \* (1.0 — a) + y \* a (это линейная интерполяция между x и y).
float2 mix(float2 x, float2 y, float2 a)
float3 mix(float3 x, float3 y, float3 a)
float4 mix(float4 x, float4 y, float4 a)
float smoothStep(float edge0, float edge1, float x) Если x <= edge0, возвращает 0. Если x >= edge1, возвращает 1, иначе выполняется сглаженная интерполяция (**Прим. пер.:** в оригинале — smooth hermite interpolation).
float2 smoothStep(float2 edge0, float2 edge1, float2 x)
float3 smoothStep(float3 edge0, float3 edge1, float3 x)
float4 smoothStep(float4 edge0, float4 edge1, float4 x)
**Геометрические функции:**
Эти функции работают с векторами как с целым объектом, а не рассматривают каждый элемент вектора, как отдельный.
float length(float x) Возвращает длину вектора х
float length(float2 x)
float length(float3 x)
float length(float4 x)
float distance(float x, float y) Возвращает расстояние между х и у
float distance(float2 x, float2 y)
float distance(float3 x, float3 y)
float distance(float4 x, float4 y)
float dot(float x, float y) Возвращает скалярное произведение х на у
float dot(float2 x, float2 y)
float dot(float3 x, float3 y)
float dot(float4 x, float4 y)
float3 cross(vector3 x, vector3 y) Возвращает векторное произведение х на у
float normalize(float x) Возвращает вектор с тем же направлением, что и х, но с длиной равной 1 и *undefined* если length(x) == 0
float2 normalize(float2 x)
float3 normalize(float3 x)
float4 normalize(float4 x)
Эти функции выполняют покомпонентное перемножение (в отличие от оператора \*, который выполняет алгебраическое перемножение матриц):
float2x2 matrixCompMult(float2x2 x, float2x2 y) Возвращает покомпонентное перемножение х на у
float3x3 matrixCompMult(float3x3 x, float3x3 y)
float4x4 matrixCompMult(float4x4 x, float4x4 y)
Эти функции сравнивают вектора покомпонентно и возвращают булево значение той же размерности (соблюдая порядок сравнения):
bool2 lessThan(int2 x, int2 y) Возвращает покомпонентное сравнение x < y
bool3 lessThan(int3 x, int3 y)
bool4 lessThan(int4 x, int4 y)
bool2 lessThan(float2 x, float2 y)
bool3 lessThan(float3 x, float3 y)
bool4 lessThan(float4 x, float4 y)
bool2 lessThanEqual(int2 x, int2 y) Возвращает покомпонентное сравнение x <= y
bool3 lessThanEqual(int3 x, int3 y)
bool4 lessThanEqual(int4 x, int4 y)
bool2 lessThanEqual(float2 x, float2 y)
bool3 lessThanEqual(float3 x, float3 y)
bool4 lessThanEqual(float4 x, float4 y)
bool2 greaterThan(int2 x, int2 y) Возвращает покомпонентное сравнение x > y
bool3 greaterThan(int3 x, int3 y)
bool4 greaterThan(int4 x, int4 y)
bool2 greaterThan(float2 x, float2 y)
bool3 greaterThan(float3 x, float3 y)
bool4 greaterThan(float4 x, float4 y)
bool2 greaterThanEqual(int2 x, int2 y) Возвращает покомпонентное сравнение x >= y
bool3 greaterThanEqual(int3 x, int3 y)
bool4 greaterThanEqual(int4 x, int4 y)
bool2 greaterThanEqual(float2 x, float2 y)
bool3 greaterThanEqual(float3 x, float3 y)
bool4 greaterThanEqual(float4 x, float4 y)
bool2 equal(int2 x, int2 y) Возвращает покомпонентное сравнение x == y
bool3 equal(int3 x, int3 y)
bool4 equal(int4 x, int4 y)
bool2 equal(float2 x, float2 y)
bool3 equal(float3 x, float3 y)
bool4 equal(float4 x, float4 y)
bool2 equal(bool2 x, bool2 y)
bool3 equal(bool3 x, bool3 y)
bool4 equal(bool4 x, bool4 y)
bool2 notEqual(int2 x, int2 y) Возвращает покомпонентное сравнение x != y
bool3 notEqual(int3 x, int3 y)
bool4 notEqual(int4 x, int4 y)
bool2 notEqual(float2 x, float2 y)
bool3 notEqual(float3 x, float3 y)
bool4 notEqual(float4 x, float4 y)
bool2 notEqual(bool2 x, bool2 y)
bool3 notEqual(bool3 x, bool3 y)
bool4 notEqual(bool4 x, bool4 y)
Эти функции работают только с векторами логического типа:
bool any(bool2 x) Возвращает истину если хотя бы один элемент х является истинным
bool any(bool3 x)
bool any(bool4 x)
bool all(bool2 x) Возвращает истину если все элементы х являются истинными
bool all(bool3 x)
bool all(bool4 x)
bool2 not(bool2 x) Возвращает результат поэлементного логического отрицания
bool3 not(bool3 x)
bool4 not(bool4 x)
**P.S.:** Это мой первый пост на Хабре. Прошу сильно не пинать;) | https://habr.com/ru/post/84396/ | null | ru | null |
# Rust crashcourse. Итераторы
> Ниже представлен перевод одной из частей серии статей Rust Crash Course от Майкла Сноймана, которая посвящена итераторам. Мне материал показался удачным в плане доступности изложения, поэтому перевод, сделанный для себя, решил опубликовать. Надеюсь, что это кому-то пригодится. Если данный материал будет интересен, то опубликую ещё несколько переводов из этой серии.
>
>
>
> Так же постарался переводить максимально близко к авторскому стилю, но сократил немного междомедий и восклицаний, не сильно значимых для смысла.
Больше итераторов!
------------------
Лично для себя я обнаружил, что проще всего понять работу итераторов, написав несколько из них самому, так что с этого и начнём.
Займёмся программированием под руководством компилятора (compiler-guided). Ранее мы уже обсуждали, что существует трейт `Iterator`. Так что бьюсь об заклад, что нам нужно создать новый тип данных и предоставить реализацию этого трейта. Начнём с чего-нибудь простого — итератора, который не продуцирует значений вообще.
```
struct Empty;
fn main() {
for i in Empty {
panic!("Wait, this shouldn't happen!");
}
println!("All done!");
}
```
Паника (`panic!()`) — способ завершить текущий поток при возникновении невозможной ситуации. Это похоже на исключения (runtime exceptions) в других языках, за исключением того, что невозможно восстановить работоспособность. Так что её следует использовать только для подобных ситуаций.
Скомпилируем это и получим полезное сообщение об ошибке:
```
error[E0277]: `Empty` is not an iterator
--> src/main.rs:5:14
|
5 | for i in Empty {
| ^^^^^ `Empty` is not an iterator
|
= help: the trait `std::iter::Iterator` is not implemented for `Empty`
= note: required by `std::iter::IntoIterator::into_iter`
```
Давайте добавим пустую реализацию:
```
impl Iterator for Empty {
}
```
И получим ещё подсказку от компилятора:
```
error[E0046]: not all trait items implemented, missing: `Item`, `next`
--> src/main.rs:4:1
|
4 | impl Iterator for Empty {
| ^^^^^^^^^^^^^^^^^^^^^^^ missing `Item`, `next` in implementation
|
= help: implement the missing item: `type Item = Type;`
= help: implement the missing item: `fn next(&mut self) -> std::option::Option<::Item> { todo!() }`
```
Таким образом, нам нужно предоставить в реализации две сущности: `Item` и `next()`, которая является функцией, и к ней мы вернёмся во вторую очередь. Так что насчёт `type Item`? Это то, что зовётся ассоциированным типом (associated type). Он сообщает, какой тип значений продуцируется итератором. Ну так как мы ничего не продуцируем, мы можем использовать любой тип. Я буду использовать `u32`:
```
struct Empty;
impl Iterator for Empty {
type Item = u32;
}
```
Ну а теперь нужно добавить что-нибудь в `next`. Выше в сообщении был предоставлен тип этой функции:
```
fn next(&mut self) -> std::option::Option<::Item>
```
Немного упростим. `&mut self` — это сокращение для `self: &mut Self`. Далее мы можем удалить квалификаторы модулей для `Option` и `Iterator`, так как они уже и так в нашей области видимости имён (namespace):
```
fn next(&mut self) -> Option<::Item>
```
Это `Self as Iterator` выглядит интересно и обозначает: "возьми текущий тип и загляни в реализацию трейта `Iterator`". Причина, по которой мы позаботились об указании реализации в том, что следует дальше — `::Item`. То, что мы на самом деле хотим выразить, звучит как "мы хотим ассоциированный тип `Item`, связанный с реализацией `Iterator`". Возможна ситуация, когда в других трейтах будут существовать ассоциированные типы с тем же самым именем, так что это просто способ однозначно сослаться на конкретный тип.
Теперь посмотрим, действительно ли это всё работает? Включим имя функции и предоставим тупое тело:
```
struct Empty;
impl Iterator for Empty {
type Item = u32;
fn next(&mut self) -> Option<::Item> {
unimplemented!()
}
}
```
`unimplemented!()` — макрос, который использует под своим капотом `panic!()` и является согласованным способом предоставить реализацию в процессе активной разработки. Если у вас всё компилируется, то всё должно быть хорошо. Потом программа падает (крэшится) при выполнении из этого самого `unimplemented!()`.
> Прим. В современных версиях Rust вместо макроса `unimplemented!()` рекомендуется использовать макрос `todo!()`, о чём компилятор услужливо сообщает в подсказке при ошибке отсутствия метода `next()`.
Мы можем ещё упростить сигнатуру функции, удалив `as Iterator`, который не является необходимым:
```
fn next(&mut self) -> Option
```
Если хотите, так же можно заменить `Self::Item` напрямую на `u32`. Из достоинств — это короче, но недостаток в том, что если вы поменяете `Item` в будущем, то вам придётся менять его в двух местах. Так что это на ваше усмотрение.
Теперь предоставим реализацию. Мы возвращаем `Option`, который является перечислением (`enum`) двух вариантов: `None` и `Some`. Первый значит "у нас ничего нет", второй — "у нас есть кое-что". Исходя из этого, реализация пустого итератора, возвращающего `None` выглядит как то, что нам нужно:
```
struct Empty;
impl Iterator for Empty {
type item = u32;
fn next(&mut self) -> Option {
None
}
}
```
И вот так просто мы получили нашу первую реализацию `Iterator`.
### Упражнение
Создать итератор, который будет бесконечно продуцировать число `42`. Вот функция `main` для этого.
```
fn main() {
// only take 10 to avoid looping forever
for i in TheAnswer.take(10) {
println!("The answer to life, the universe, and everything is {}", i);
}
println!("All done!");
}
```
**Решение**
```
struct TheAnswer;
impl Iterator for TheAnswer {
type Item = u32;
fn next(&mut self) -> Option {
Some(42)
}
}
```
Мутабельное состояние
---------------------
Сигнатура метода `next` включает в себя мутабельную ссылку на `self`. Давайте использовать её! Мы собираемся создать итератор, который считает от 1 до 10. (Если чувствуете достаточную храбрость, то попробуйте реализовать его самостоятельно, прежде, чем увидите моё решение).
```
struct OneToTen(u32);
fn one_to_ten() -> OneToTen {
OneToTen(1)
}
impl Iterator for OneToTen {
type Item = u32;
fn next(&mut self) -> Option {
if self.0 > 10 {
None
} else {
let res = Some(self.0);
self.0 += 1;
res
}
}
}
fn main() {
for i in one\_to\_ten() {
println!("{}", i);
}
}
```
### Упражнение
Создайте итератор, который продуцирует последовательность чисел Фибоначчи.
**Решение**
Начнём с простейшего решения
```
struct Fibs {
x: u32,
y: u32,
}
fn fibs() -> Fibs {
Fibs {
x: 0,
y: 1,
}
}
impl Iterator for Fibs {
type Item = u32;
fn next(&mut self) -> Option {
let orig\_x = self.x;
let orig\_y = self.y;
self.x = orig\_y;
self.y = orig\_x + orig\_y;
Some(orig\_x)
}
}
fn main() {
for i in fibs().take(10) {
println!("{}", i);
}
}
```
Однако же, если заменить `take(10)` на `take(47)`, то вывод программы будет выглядеть следующим образом:
```
701408733
1134903170
thread 'main' panicked at 'attempt to add with overflow', foo.rs:21:18
note: Run with `RUST_BACKTRACE=1` for a backtrace.
```
Одно из решений могло бы заключаться в использовании типа `u64`, но это просто отложит проблему. Вместо этого мы можем использовать сложение с контролем переполнения:
```
fn next(&mut self) -> Option {
let orig\_x = self.x;
let orig\_y = self.y;
match orig\_x.checked\_add(orig\_y) {
// overflow
None => None,
// no overflow
Some(new\_y) => {
self.x = orig\_y;
self.y = new\_y;
Some(orig\_x)
}
}
}
```
Теперь наш поток исполнения будет останавливаться, как только случается переполнение.
Если хотите стать более продвинутым, вы можете задействовать на два значения больше. Чтобы сделать это, вам нужно присваивать разыменованное значение и использовать тип `enum` для отслеживания состояния итератора:
```
fn next(&mut self) -> Option {
use Fibs::\*;
match \*self {
Done => None,
OneLeft(x) => {
\*self = Done;
Some(x)
}
Running(orig\_x, orig\_y) => {
\*self = match orig\_x.checked\_add(orig\_y) {
// overflow
None => OneLeft(orig\_y),
Some(new\_y) => Running(orig\_y, new\_y),
};
Some(orig\_x)
}
}
}
```
Вариант от переводчика:
```
enum FibonacciIterState {
FirstItem,
SecondItem,
NthItem(u64, u64),
Overflowed,
}
struct FibonacciIterator {
state: FibonacciIterState,
}
impl FibonacciIterator {
fn new() -> FibonacciIterator {
FibonacciIterator{ state: FibonacciIterState::FirstItem }
}
}
impl Iterator for FibonacciIterator {
type Item = u64;
fn next(&mut self) -> Option<::Item> {
match self.state {
FibonacciIterState::FirstItem => {
self.state = FibonacciIterState::SecondItem;
Some(0)
},
FibonacciIterState::SecondItem => {
self.state = FibonacciIterState::NthItem(0, 1);
Some(1)
},
FibonacciIterState::NthItem(prev, last) => {
if let Some(next) = prev.checked\_add(last) {
self.state = FibonacciIterState::NthItem(last, next);
Some(next)
} else {
self.state = FibonacciIterState::Overflowed;
None
}
},
FibonacciIterState::Overflowed => {
None
}
}
}
}
```
Адаптеры итераторов
-------------------
Мы так же можем написать итератор, который будет изменять поведение существующего итератора. Давайте напишем итератор удвоитель (Doubler), который будет увеличивать в два раза значения, продуцированные предыдущим итератором. Для того, чтобы заставить это работать, мы захватим нижележащий итератор и обернём его в новый тип данных, который так же осуществляет параметризацию содержимого итератора:
```
struct Doubler *{
iter: I,
}*
```
Давайте заглянем в функцию `main`, чтобы показать, как это используется:
```
fn main() {
let orig_iter = 1..11; // итератор от 1 до 10
let doubled_iter = Doubler {
iter: orig_iter,
};
for i in doubled_iter {
println!("{}", i);
}
}
```
Если скомпилировать это, то получим ошибку из-за отсутствия реализации трейта `Iterator`. Напишем её:
```
impl Iterator for Doubler {
}
```
При компиляции получаем сообщение об ошибке:
```
error[E0107]: wrong number of type arguments: expected 1, found 0
--> src/main.rs:6:19
|
6 | impl Iterator for Doubler {
| ^^^^^^^ expected 1 type argument
```
Ок, это звучит разумно. `Doubler` сам по себе не является типом до тех пор, пока мы не зададим его параметры. Так что сделаем это:
```
impl Iterator for Doubler *{
}*
```
Получили два сообщения об ошибках. Можете посмотреть на второе, но это не слишком полезно. (Рекомендация: сначала всегда смотрите на первое сообщение об ошибке и пытайтесь её исправить прежде, чем двигаться дальше).
Первое сообщение:
```
error[E0412]: cannot find type `I` in this scope
--> foo.rs:5:27
|
5 | impl Iterator for Doubler *{
| ^ not found in this scope*
```
Так что же происходит? Когда мы предоставляем реализацию, нам нужно указать все типовые переменные, которые хотим использовать заранее. Сделаем так:
```
impl *Iterator for Doubler *{
}**
```
Это может выглядеть избыточно (как и для меня поначалу), но в конечном счёте у вас будут более сложные случаи, и эти два набора угловых скобок не будут одинаковыми.
Теперь мы приблизились к решению, и компилятор ругается на отсутствие `type Item` и `next`. Двинемся дальше и вернём `u32` снова:
```
type Item = u32;
fn next(&mut self) -> Option {
unimplemented!()
}
```
Уже компилируется и запускается, а затем падает на `unimplemented!`. Отлично, есть прогресс!
Трюк здесь в том, что мы хотим попросить следующее значение у нижележащего итератора. Так что сделаем это с помощью явного сопоставления шаблонов (для функциональщиков: да, здесь тоже есть метод `map` у типа `Option`, который можно использовать):
```
fn next(&mut self) -> Option {
match self.iter.next() {
None => None,
Some(x) => Some(x \* 2),
}
}
```
Достаточно симпатично, но при компиляции получаем:
```
error[E0599]: no method named `next` found for type parameter `I` in the current scope
--> src/main.rs:9:25
|
9 | match self.iter.next() {
| ^^^^ method not found in `I`
|
= help: items from traits can only be used if the type parameter is bounded by the trait
help: the following traits define an item `next`, perhaps you need to restrict type parameter `I` with one of them:
|
6 | impl Iterator for Doubler *{
| ^^^^^^^^^^^^^^^^^^^^^^
6 | impl Iterator for Doubler *{
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^**
```
Компилятор знает, что мы *наверное* имеем в виду метод `next` из трейта `Iterator`. Но он не использует его. Можно задаться вопросом, почему же так происходит. Потому что *мы не сказали компилятору, что эта реализация трейта существует*! Нам нужно указать, что параметр `I` должен иметь реализацию трейта `Iterator`.
```
impl Iterator for Doubler
```
Это немного новый синтаксис, но достаточно прямолинейный: `I` должно иметь реализацию трейта `Iterator`. К сожалению, это ещё не всё, что нам нужно:
```
error[E0369]: cannot multiply `{integer}` to `*::Item`
--> src/main.rs:11:31
|
11 | Some(x) => Some(x \* 2),
| - ^ - {integer}
| |
| *::Item
|
= note: the trait `std::ops::Mul` is not implemented for `*::Item`***
```
Обсудим этот момент. `I` — это какой-то `Iterator`, что мы уже установили. И мы знаем, что значение `x`, которое мы используем в `x * 2` будет ассоциированным с `I` типом `Item`. Проблема в том, что мы понятия не имеем, какой это будет тип, и поддерживает ли он операцию умножения!
Уже говорилось, что мы собираемся продуцировать тип `u32`, так что можем ли мы принудительно указать, что `Item` является типом `u32`? Да!
```
impl> Iterator for Doubler
```
Юху, наш код работает!
Альтернативный синтаксис: ключевое слово `where`
------------------------------------------------
Поскольку ограничения становятся всё более сложными, указание их всех в параметрах в начале `impl` начинает выглядеть перегруженным. Вы можете использовать `where` как альтернативу для этого:
```
impl *Iterator for Doubler*where I: Iterator**
```
Люди руководствуются субъективной точкой зрения при принятии решения на переход к этой конструкции. Лично я предподчитаю единообразие (consistency) краткости, и почти всегда использую `where`. Вы можете придерживаться своего взгляда. Так же вы должны знать оба синтаксиса для чтения чужого кода.
Не только u32
-------------
Немного странно, что мы привязались к `u32` типу. Что, если мы поменяем нашу функцию `main` вот так:
```
let orig_iter = 1..11u64;
```
Получим ошибку компиляции:
```
error[E0271]: type mismatch resolving ` as std::iter::Iterator>::Item == u32`
--> src/main.rs:24:14
|
24 | for i in doubled\_iter {
| ^^^^^^^^^^^^ expected `u64`, found `u32`
|
= note: required because of the requirements on the impl of `std::iter::Iterator` for `Doubler>`
```
Возможно ослабить это ограничение, но ценой некоторого усложнения. Но давайте сделаем это! Удалим все указания на `u32` из нашей реализации. Вот первая попытка:
```
impl *Iterator for Doubler*where I: iterator
{
type Item = ???;
fn next(&mut self) -> Option {
match self.iter.next() {
None => None,
Some(x) => Some(x \* 2),
}
}
}**
```
Я заменил все `Option` на `Option` и удалил у `I: Iterator`. Но что нужно указывать для `type Item=`? Хочется, чтобы оно было тем же типом, что и `Item` у нижележащего итератора. Так давайте так и укажем!
```
type Item = I::Item;
```
Работает! Но всё ещё не компилируется, потому что компилятор не знает, как выполнять операцию умножения для `I::Item`. К счастью, есть трейт `Mul` для типов, которые поддерживают умножение. Мы можем добавить его:
```
where
I: Iterator,
I::Item: std::ops::Mul,
```
Новое сообщение об ошибке:
```
error[E0308]: mismatched types
--> foo.rs:14:29
|
14 | Some(x) => Some(x * From::from(2u8)),
| ^^^^^^^^^^^^^^^^^^^ expected std::iter::Iterator::Item, found std::ops::Mul::Output
|
= note: expected type `*::Item`
found type `<*::Item as std::ops::Mul>::Output`**
```
Оказывается, у трейта `Mul` есть ассоциированный тип для выходного значения. Это полезно для выражения более сложных отношений на уровне типов. Например, мы можем определить типы для Силы (`Force`), Массы (`Mass`) и Ускорения (`Acceleration`), а затем определить реализацию трейта `Mul`, которая умножает тип Масса(`Mass`) на тип Ускорение(`Acceleration`), и порождает значение типа Сила(`Force`).
Это замечательная фича, но она нам здесь лишь мешает. Мы хотим лишь сказать, что тип выходного значения должен быть тот же, что и у `item`:
```
impl *Iterator for Doubler*whereI: Iterator,
I::Item: std::ops::Mul,**
```
И теперь уже получаем:
```
error[E0308]: mismatched types
--> foo.rs:14:33
|
14 | Some(x) => Some(x * 2),
| ^ expected associated type, found integral variable
|
= note: expected type `*::Item`
found type `{integer}`*
```
Ух. У нас есть `2`, которое может быть *каким-нибудь* встроенным типом. Но мы не знаем, что `Item` является каким-то встроенным типом. Я не знаю, как задать ограничение так, чтобы этот код работал (если кто знает — пишите, я обновлю текст). Один трюк, который работает, заключается в расширении (upcast) типа `u8` при помощи трейта `From`, который выполняет безопасные числовые преобразования (которые не могут привести к переполнению или усечению).
```
impl *Iterator for Doubler*where
I: iterator,
I::Item: std::ops::Mul + From,
{
type Item = I::Item;
fn next(&mut self) -> Option {
match self.iter.next() {
None => None,
Some(x) => Some(x \* From::from(2u8)),
}
}
}**
```
Фух, наконец-таки закончили!
### Упражнение
Более простое задание к вышеописанному — использовать `x + x` вместо `x * 2`. Перепишите итератор для этого. Подсказка: компилятор не будет знать, что ему можно делать копии заданного типа до тех пор, пока ему не сообщить об этом через указание соответствующего трейта.
**Решение**
```
impl *Iterator for Doubler*where
I: Iterator,
I::Item: std::ops::Add + Copy,
{
type Item = I::Item;
fn next(&mut self) -> Option {
match self.iter.next() {
None => None,
Some(x) => Some(x + x),
}
}
}**
```
Резюме
------
Получилось много. Надеюсь, это все дало идеи, как работают итераторы. Мы можем писать обобщённые адаптеры, которые будут работать со множеством типов данных. Вы можете применить `Doubler` к итератору диапазона, как мы это и сделали. Вы так же можете применить его к пустому итератору `Empty`, который писали ранее. Или к дюжинам других итераторов.
Вы можете заметить, что типы этих итераторов разрастаются по мере того, как вы добавляете больше возможностей в них. Это действительно так, и это так и задумано. Статически представляя тип полный тип, компилятор может видеть все действия, которые выполняются в конвейере опеций итераторов, и очень хорошо их оптимизировать.
Больше идиоматичности
---------------------
Адаптер `Doubler`, который мы написали, не идеоматичен вообще. Вот как это делается в *реальной жизни*:
```
fn main() {
for i in (1..11).map(|x| x * 2) {
println!("{}", i);
}
}
```
Трейт `Iterator` включает в себя множество вспомогательных методов, которые могут быть собраны в длинную цепочку действий. Например:
```
fn main() {
for i in (1..11).skip(3).map(|x| x + 1).filter(|x| x % 2 == 0) {
println!("{}", i);
}
}
```
Вы можете написать подобное как цикл на C/C++, но:
* Будет сложнее проследить логику
* Будет сложнее расширить возможности в будущем
* Это не будет быстрее: компилятор оптимизирует такие к тому же развёрнутому коду, который вы можете написать руками
Коллекционирование результатов
------------------------------
Вы можете собрать результаты работы итератора в вектор:
```
fn main() {
let my_vec: Vec = (1..11).collect();
println!("{:?}", my\_vec);
}
```
Указание типа тут необходимо, так как `collect` может работать со множеством различных типов данных.
### Упражнение
Используйте метод `fold` для получения суммы чисел от 1 до 10. Дополнительно: напишите вспомогательную функцию `sum`.
**Решение**
Метод `fold` принимает два параметра: начальное значение и функцию для сложения суммы со следующим значением. Одно из решений заключается в использовании замыканий:
```
fn main() {
let res = (1..11).fold(0, |x, y| x + y);
println!("{}", res);
}
```
Другое решение заключается в прямом обращении к функции сложения. Помните, как мы указывали трейт `Mul` для оператора `*`? Так же существует трейт `Add` для сложения:
```
fn main() {
let res = (1..11).fold(0, std::ops::Add::add);
println!("{}", res);
}
```
Касательно написания собственной функции суммирования: мы опять упираемся в ситуацию, когда всё становится обобщённым и нам приходится указывать соответствующие трейты. Будем придерживаться аналогичного подхода, который использовался в случае трейта `From` и типа `u8`:
```
fn sum*(iter: I) -> I::Item
where
I: Iterator,
I::Item: std::ops::Add + From,
{
iter.fold(From::from(0u8), std::ops::Add::add)
}*
``` | https://habr.com/ru/post/533204/ | null | ru | null |
# Эволюция веб-фреймворков Microsoft. ASP.NET vNext
#### Предпосылки к переменам
Новость о выходе ASP.NET vNext в сети распространилась достаточно быстро вместе с анонсом наиболее интересных новшеств, предложенных в обновлении. ASP.NET MVC 6 получил новое имя и позиционируется как что-то действительно новое в среде web фреймворков Microsoft (MS). Для того чтобы наиболее полно можно было понимать важность заявленных изменений vNext, вспомним особенности текущей реализации веб приложений на платформе .NET.
Типичное ASP.NET MVC приложение состоит из Global.asax файла, в котором мы расширяем класс HttpApplication (System.Web) и таким образом добавляем желаемое поведение обработки Http запросов путем конфигурирования отдельных составляющих компонентов MVC. В классическом ASP.NET MVC класс Router (System.Web.Routing) является неотъемлемым звеном обработки Http запросов, путем перенаправления их на нужный HttpHandler – в стандартном поведении (MvcRouteHandler) который создает фабрику контроллеров и запускает дальнейший pipe обработки запросов. Эти компоненты являются заведомо тесно привязанными к веб-серверу от MS – Internet Information Services (IIS), использующий HttpHandlers и HttpContext (доступ к параметрам http запроса/ответа) для обработки запросов. Полученное в наследие от ASP.NET Web Forms повсеместное применение этих компонентов в MVC предполагало тесную интеграцию с IIS, что сделало невозможным использование альтернативного веб-сервера для хостинга приложений. Эти обстоятельства с течением времени вызывали все больше критики со стороны сообщества разработчиков и являлись действительно не очень благоприятным фактором развития ASP.NET MVC, который будучи Open source проектом развивается куда быстрее чем Microsoft разрабатывает обновления для компонентов System.Web.
Попытка исправить ситуацию была предпринята в рамках развития проекта Web Api. Во время миграции с фреймворка MS WCF разработчики отказались от подхода к построению RESTful сервисов на базе концепции «привязок-контрактов», в пользу более удобному MVC, что предопределило много общего и созвучное название — ASP.NET Web Api. На самом же деле разработчики нового фреймворка смогли сделать его с оглядкой на описанные выше недостатки ASP.NET MVC. В Web Api не использовали этих самых компонентов System.Web напрямую благодаря адаптерам для HttpContext.Request, HttpContext.Response – абстракциям c обновленной структурой HttpRequestMessage, HttpResponseMessage, в которые HttpControllerHandler (точка входа в Web Api приложение) производил преобразование указанных объектов. Так же была устранена и зависимость от HttpHandler’ов IIS, путем обработки запросов через цепочку вложенных друг в друга HttpMessageHandlers (System.Net.Http), на базе которых и был реализован обновленный стек (filters, dispatchers, delegating handlers, controllers).
Все эти изменения позволили сделать Web Api приложение независимым от хоста и развивать в рамках OWIN (Open Web Interface) спецификации. Ключевым стало понятие middleware – компоненты веб приложения (в IIS – HttpModules) и application delegate, который вместо HttpContext, взаимодействует с куда более абстрактным набором параметров запроса/ответа в хеш-мапе вида IDictionary.
Несмотря на все преимущества, гибкость, улучшенную расширяемость и целый ряд исправлений архитектурных недостатков Web Api все же не мог стать полноценной заменой MVС будучи ориентированным на Single Page Applications(SPA). В то же время один фреймворк ничем не мешал другому. Более того, они отлично уживались рядом в одном веб-приложении в случае использования IIS для их хостинга и даже могли использовать общие Http модули, например, для аутентификации. Тем не менее рассмотренный подход требовал четкого разделения ответственности в приложении и учета особенности, что все-таки Web Api и Mvc используют совершенно различный pipeline для обработки запросов. Последнее добавляло другого рода сложностей разработчикам и предполагало последующий рефакторинг в новой версии фреймворка, который и получил название vNext.
#### Шаблон проекта ASP.NET vNext
Первое, что бросается в глаза в новом веб-приложении — отсутствие файлов конфигурации web.config, packages.config и даже AssemblyInfo.cs.
В структуре решения имеем только два файла:
* project.json – файл конфигурации для проекта, где находятся зависимости с указанием версий подключаемых сборок, параметры компиляции проекта, метаданные, перечень зависимостей для развертывания в режимах .NET и Core CLR.
* Startup.cs – входная точка, класс веб-приложения.
Сейчас заглянув в свойства проекта VS мы не увидим того изобилия опций, которыми прежде были снабжены проекты ASP.NET. Всего доступны две вкладки: General – конфигурация пространства имен и типа приложения при построении; на вкладке Debugging – номер порта, на котором будет доступно наше приложение.
Далее интересней, собственно файл конфигурации project.json проекта. Выглядит он приблизительно следующим образом.
Первичный набор предусматривает наличие всего двух ключей.
* dependencies – указание зависимостей для проекта получаемых из сборок, NuGet Packages и даже исходников на диске;
* configurations – перечень зависимостей при построении проекта для конкретной целевой среды: .NET или Core CLR.
Столь кардинальные изменения в структуре проекта обусловлены использованием нового компилятора Roslyn, который позволяет в runtime компилировать исходный код в IL и выполнять его. Возможности Roslyn легли в основу и новой среды выполнения K Language Runtime (KLR). На данный момент для нее предусмотрено две опции запуска проекта в режиме .NET Desktop, либо — Core CLR (в alpha версии режим доступен только в KLR из под Win 8). Собрать проект можно так же используя K Versions Manager (KVM)/K Packages Manager (KPM) — консольные утилиты поставляемые с K, что позволяют самостоятельно управлять установленным версиями KRE(K Runtime Engine), распаковывать приложения на основании project.json и запускать их. Для более детальной информации стоит ознакомиться с ресурсом [github.com/aspnet/home](https://github.com/aspnet/home).
#### Структура веб-приложения ASP.NET vNext
Единственный файл исходного кода в проекте — Startup.cs, содержит ссылку на пространство имен Microsoft.AspNet.Builder и класс, структурой схожей с OWIN based приложениям. В нем один метод — Configure с входным параметром типа IBuilder. Проект компилируется и запускается, но ничего не возвращает в качестве ответа (а точнее возвращает «403-ий», поскольку IIS не находя обработчика запроса пытается получить доступ к файловой системе), что логично, поскольку мы не добавили никакого middleware.
На [www.asp.net/vnext](http://www.asp.net/vnext) нам предлагают вызвать статический extension метод (UseWelcomePage), чтобы добавить простейший Request Handler, но он нам мало интересен, так как скрывает всю специфику работы интерфейса IBuilder. Попробуем «копнуть» глубже взглянув на его определение:
```
using System;
namespace Microsoft.AspNet.Builder
{
public interface IBuilder
{
IServiceProvider ApplicationServices { get; set; }
IServerInformation Server { get; set; }
RequestDelegate Build();
IBuilder New();
IBuilder Use(Func middleware);
}
}
```
Для того что бы сориентироваться в коде, необходимо вспомнить, что понятие middleware в OWIN напрямую относиться к Application Delegate, который получает перечень параметров Http запроса и выполняет над ним какое-то преобразование, возвращая Task.
```
Func, Task>
```
Для OWIN мы также имели статический Extensions method на уровне интерфейса IAppBuilder, который позволял добавлять middleware используя более удобную структурированную версию контекста — IOwinContext. В vNext он немного преобразился, поскольку подразумевает работу с HttpContext напрямую. Последний теперь находится в пространстве имен Microsoft.AspNet.Http, и не имеет ничего общего с HttpContext из System.Web, как это было в случае с оберткой HttpContextBase в ASP.NET MVC:
```
public delegate Task RequestDelegate(HttpContext context);
```
Таким образом все понемногу становится на свои места — RequestDelegate в vNext и есть тем самым OWIN Application Delegate’ом.
Для добавления нового middleware в оригинальной реализации метода Use мы передаем generic делегат, содержащий в качестве параметра вложенный делегат типа RequestDelegate. Внешний Generic делегат ссылается на весь дальнейший pipeline обработки http запроса, RequestDelegate – выполняет работу Http Handler’a.
Попробуем взглянуть на пример с добавлением модулей — это должно немного прояснить ситуацию.
```
public void Configure(IBuilder app)
{
app.Use(next =>
httpContext =>
httpContext.Response.WriteAsync("Executed before all followers." + Environment.NewLine)
.ContinueWith(task => next(httpContext)));
app.Use(next =>
httpContext =>
next(httpContext)
.ContinueWith(task =>
httpContext.Response.WriteAsync("Executed after all followers." + Environment.NewLine)));
app.Use((httpContext, next) => httpContext.Response.WriteAsync("Hello world middleware." + Environment.NewLine));
}
```
Как видим, при конфигурации middleware мы имеем поведение во многом схожее с Delegating Handlers Web Api, где мы можем гибко контролировать последовательность выполнения из текущего модуля всего дальнейшего pipeline (параметр next). Достаточно просто добавить обработку Http запроса внутри лямбда-выражений передаваемых в Use.
Что же касается непосредственно OWIN, vNext является полностью совместимым с данным интерфейсом. В пространстве имен Microsoft.AspNet.Builder находится класс статических методов расширений для IBuilder, которые создают адаптеры перехода от Owin Application Delegate к vNext RequestDelegate.
```
using AddMiddleware = Action, Task>, Func, Task>>>;
public static AddMiddleware UseOwin(this IBuilder builder)
{
....
}
```
В своем приложении мы можем использовать AddMiddleware для взаимодействия между OWIN Environment dictionary и vNext HttpContext, полагаясь на внутреннею реализацию платформы. Расширение позволит достаточно легко использовать OWIN-компоненты в новой версии фреймворка.
Из важных особенностей стоит отметить, что в отличие от OWIN AppBuilder’a, vNext IBuilder интерфейс содержит и встроенный сервис-локатор ApplicationServices инициализируемый приложением веб-сервером. В данном свойстве предоставляется доступ Web Host Application Level Services.
#### vNext HttpContext
Со структурой приложения немного разобрались, что же представляет из себя обновленный vNext HttpContext. Как и ожидалось, сам класс контекста, Request и Response объявлены абстрактными. HttpContext в реализации поставляемого «из кробки» хоста Microsoft.AspNet.Hosting инстанцируется объектом DefaultHttpContext перед каждым вызовом цепочки middleware. Контекст имеет метод Abort, реализует интерфейс IDisposable и предоставляет два сервис локатора ApplicationServices и RequestServices с соответствующим жизненным циклом контейнеров, что явно говорит в пользу более удобного формирования Structure Map на уровне приложения по сравнению с предыдущими версиями ASP.NET MVC.
В vNext добавлен новый механизм расширяемости контекста путем использования HttpFeatures. На уровне интерфейса контекста он предусматривает два набора методов для получения и добавления расширений (через запаковку в object и generic wrapper):
```
public abstract object GetFeature(Type type);
public abstract void SetFeature(Type type, object instance);
public virtual T GetFeature()
{
return (T)GetFeature(typeof(T));
}
public virtual void SetFeature(T instance)
{
SetFeature(typeof(T), instance);
}
```
В обновленной версии ASP.NET данный подход применяется для динамического формирования контекста начиная от первого обращения к HttpContext, где инициализируются Host Application/Server Specific Features и вплоть до уровня использования отдельными middleware компонентами параметров запроса, аутентификации, кеширования, работы с веб-сокетами. В базовой реализации Request практически полностью использует интерфейсы, определенные в Microsoft.AspNet.Builder, для получения составляющих именно из HttpFeatures. Формирование контекста таким образом позволяет скрывать за конкретным интерфейсом отдельного компонента специфическую для веб-сервера реализацию функциональности на уровне хоста не ограничиваясь базовой структурой HttpContex.
#### vNext MVC
Наиболее ожидаемым нововведением с точки зрения построения самого веб-приложения безусловно есть объединение функциональности ASP.NET MVC и Web Api в рамках одного фреймворка, что позволит использовать общий pipeline для обработки Http запросов.
Добавление поведения MVC в vNext предполагает подключение и конфигурацию двух модулей middleware:
* vNext Dependency Resolver с перечнем сервисов формирующих стек vNext MVC.
* Router middleware — модуль MVC роутера.
```
public void Configure(IBuilder app)
{
app.UseServices(services => services.AddMvc());
app.UseMvc(router =>
router.MapRoute("DefaultHome",
"{controller}/{action}/{id?}",
defaults: new { Controller = "Home", Action = "Index" }));
}
```
Первый из них — набор сервисов, предоставляющий реализацию стандартных MVC компонентов и используемый на протяжении всего pipeline для обработки запроса на уровне отдельных абстракций. Речь идет о поставщиках Action контекста, фабрики контроллеров, привязки модели, предоставления View Engine и т.д. Описание сервисов с маппингами DI доступно для ознакомления в классе Microsoft.AspNet.Mvc.MvcServices.cs.
Второй — RouterHandler, который представлен в vNext интерфейсом IRouter с асинхронным методом RouteAsync:
```
public interface IRouter
{
Task RouteAsync(RouteContext context);
string GetVirtualPath(VirtualPathContext context);
}
```
По умолчанию интерфейс реализует класс MvcRouteHandler. В отличии от предыдущих версий роутинга основанных на специфической для фреймворка функциональности (в MVC – HttpHandler, Web Api – DelegatingHandler), в этот раз в нем предусмотрен только вызов отдельных методов интерфейсов полученных из сервис локатора с набором компонентов MVC. Именно этот класс получает ActionContext и запускает дальнейший pipeline обработки запроса, используя IActionInvoker сервис в связке с ControllerFactory. Основное преимущество от применения такого подхода очевидно, он предоставляет необходимую универсальность для слияния фреймворков, которая отсутствовала прежде.
Еще одним положительным изменением в новой редакции MVC стал полностью асинхронный режим выполнения методов сервисов. Подобным образом был реализован pipe в Web Api и позволил полностью вынести из рабочего пула потока веб-сервера операции связанные с ожиданием ресурсов. MVC до текущего момента предусматривал «из коробки» только асинхронные контроллеры.
За основную рабочую единицу обработки Http запроса в vNext был взят Controller из MVC. Для пост-процессинга и сериализации результатов выполнения действий используется интерфейс IActionResult. Функционал MVC в этом отношении концептуально остался прежним. Что же касается основных расширений, хорошо зарекомендовавших себя в Web Api, то они на данный момент не были добавлены в pipeline vNext. Как например механизм определения форматера путем использования Content Negotiation сервисов. В случае возвращения экземпляра класса не реализующего IActionResult из действия контроллера используется JSON-форматер.
Механизм конфигурации приложения был сильно модифицирован в связи с переходом на обновленный шаблон проекта. Теперь вместо прежнего web.config применяется config.json, представляющий иерархическую структуру пар ключ-значение.
Непосредственно на уровне кода, предоставлен набор утилит из пространством имен Microsoft.Framework.ConfigurationModel, производящий слияние ключей из различных источников конфигурации, например, параметров запуска приложения-хоста, переданных в консоли K; пар определенных в файлах project.json, config.json веб-приложения.
Про каждый из компонентов, а также и те, что не были упомянуты, можно написать отдельный обзор и наверняка он еще будет не один. Учитывая, что и перечень функциональных составляющих нового фреймворка еще не утвержден окончательно, ограничимся базовым пониманием работы его основных компонентов.
#### Итоги
После ознакомления с alpha версией ASP.NET MVC vNext можно действительно говорить, что перемены разработчиков ожидают достаточно кардинальные. Cвязанные они не только с основательным рефакторингом ASP.NET, но и с адаптацией фреймворка под обновленный Runtime.
На уровне приложения изменение внутренних концепций достаточно ограниченное и будет интуитивно понятным для разработчиков, имевших дело с OWIN и предыдущими версиями ASP.NET MVC.
С точки зрения самого фреймворка наиболее важным есть переход на открытый веб интерфейс и четкое разграничение ответственности между хостом и веб-приложением. Качественное обновление состава абстракций и добавление гибких возможностей расширения, открывают новые перспективы при разработке веб-приложений.
##### Полезные ресурсы:
[www.asp.net/vnext](http://www.asp.net/vnext)
[github.com/aspnet](https://github.com/aspnet/)
[blogs.msdn.com/b/webdev/archive/2014/06/03/asp-net-vnext-in-visual-studio-14-ctp.aspx](http://blogs.msdn.com/b/webdev/archive/2014/06/03/asp-net-vnext-in-visual-studio-14-ctp.aspx)
[www.asp.net/aspnet/overview/owin-and-katana](http://www.asp.net/aspnet/overview/owin-and-katana)
[blogs.msdn.com/b/dotnet/archive/2014/05/12/the-next-generation-of-net-asp-net-vnext.aspx](http://blogs.msdn.com/b/dotnet/archive/2014/05/12/the-next-generation-of-net-asp-net-vnext.aspx) | https://habr.com/ru/post/226427/ | null | ru | null |
# Dark Launch в Istio: секретные службы
«Опасность – мое второе имя», – говаривал Остин Пауэрс, человек-загадка международного масштаба. Но то, что в почете у суперагентов и спецслужб, совсем не годится для служб компьютерных, где скукотища гораздо лучше опасностей.
И Istio вместе OpenShift и Kubernetes превращают развертывание микросервисов в дело по-настоящему скучное и предсказуемое – и это прекрасно. Об этом и о многом другом поговорим в четвертом и последнем посте из серии про Istio.
### Когда скукотища – это правильно
В нашем случае скукотища возникает только в конечной фазе, когда остается только сидеть и наблюдать за процессом. Но для этого надо всё предварительно настроить, и здесь вас ждет много интересного.
При развертывании новой версии вашего софта стоит рассмотреть все варианты минимизации рисков. Работа в параллельном режиме – это очень мощный и проверенный способ тестирования, и Istio позволяет задействовать для этого «секретную службу» (скрытую от посторонних глаз версию вашего микросервиса) без вмешательства в работу продакшн-системы. Для этого есть даже специальный термин – «Тайный запуск» (Dark Launch), который в свою очередь активируется функцией с не менее шпионским названием «зеркалирование трафика».
Обратите внимание, что в первом предложении предыдущего абзаца используется термин «развертывание» (deploy), а не «запуск» (release). Вы действительно должны иметь возможность развертывать – и, разумеется, использовать – свой микросервис так часто, как пожелаете. Этот сервис должен быть способен принимать и обрабатывать трафик, выдавать результаты, а также писать в логи и мониториться. Но при этом сам этот сервис вовсе необязательно выпускать в продакшн. Развертывание и выпуск ПО – это не всегда одно и то же. Развертывание вы можете выполнять всегда, когда захотите, а вот выпуск – только тогда, когда будете окончательно готовы.
### Организация скуки – это интересно
Взгляните на следующее правило маршрутизации Istio, которое направляет все HTTP-запросы на микросервис recommendation v1 (все примеры взяты из [Istio Tutorial GitHub repo](https://github.com/redhat-developer-demos/istio-tutorial#mirroring-traffic-dark-launch)), одновременно зеркалируя их на микросервис recommendation v2:
Обратите внимание на метку `mirror:` внизу скрина – именно она задает зеркалирование трафика. Да, вот так просто!
Результатом работы этого правила станет то, что ваша продакшн-система (v1) будет по-прежнему обрабатывать поступающие запросы, но сами запросы при этом будут асинхронно зеркалиться на v2, то есть туда будут уходить их полные дубликаты. Таким образом, вы сможете протестировать работу v2 в реальных условиях – на настоящих данных и трафике, – никак не вмешиваясь в работу продакшн-системы. Превращает ли это организацию тестирования в скукотищу? Да, безусловно. Но делается это интересно.
### Добавим драмы
Обратите внимание, что в коде v2 надо предусмотреть ситуации, когда поступающие запросы могут приводить к изменению данных. Сами запросы зеркалятся легко и прозрачно, но вот выбор способа обработки в тестовой остается за вами – а вот это уже немного волнительно.
### Повторим важный момент
Тайный запуск с зеркалированием трафика (Dark Launch/Request Mirroring) можно выполнять, никак не затрагивая код.
### Пища для размышления
А что, если место зеркалирования запросов отправлять часть из них не на v1, а на v2? Например, один процент от всех запросов или только запросы от определенной группы пользователей. И потом, уже глядя на то, как работает v2, постепенно переводить на новую версию все запросы. Или наоборот вернуть всё на v1, если с v2 что-то пойдет не так. Кажется, это называется Canary Deployment («канареечное развертывание» – термин [восходит к горному делу](http://miningwiki.ru/wiki/%D0%9A%D0%B0%D0%BD%D0%B0%D1%80%D0%B5%D0%B9%D0%BA%D0%B0_%D0%B2_%D1%88%D0%B0%D1%85%D1%82%D0%B5), и будь у него русское происхождение, он вероятно содержал бы отсылку к [кошкам](https://www.youtube.com/watch?v=7yGrgwE_k4I)), и сейчас мы это рассмотрим подробнее.
Canary Deployment в Istio: упрощаем ввод в строй
------------------------------------------------
### Осторожно и постепенно
Суть модели развертывания Canary Deployment предельно проста: при запуске новой версии своего софта (в нашем случае – микросервиса) вы сначала даете к ней доступ небольшой группе пользователей. Если всё идет нормально, вы медленно увеличиваете эту группу до тех пор, пока новая версия не начинает барахлить, или – если этого так и не происходит – в итоге переводите на нее всех пользователей. Продуманно и постепенно вводя в строй новую версию и контролируемо переключая на нее пользователей, можно снизить риски и максимизировать обратную связь.
Разумеется, Istio упрощает Canary Deployment, предлагая сразу несколько хороших вариантов для интеллектуальной маршрутизации запросов. И да, все это можно сделать, никак не трогая ваш исходный код.
### Фильтруем браузер
Один из самых простых критериев маршрутизации – это перенаправление в зависимости от браузера. Допустим, вы хотите, чтобы на v2 уходили только запросы из браузеров Safari. Вот как это делается:
Применим это правило маршрутизации и затем командой `curl` будем в цикле имитировать реальные запросы к микросервису. Как видно на скриншоте, все они уходят на v1:
А где же трафик на v2? Поскольку в нашем примере все запросы шли только из нашей же командной строки, то его попросту нет. Но обратите внимание на нижние строчки на скрине выше: это реакция на то, что мы выполнили запрос из браузера Safari, который в свою очередь выдал вот что:
### Неограниченная власть
Мы уже писали, что регулярные выражения дают очень мощные возможности для маршрутизации запросов. Взгляните на следующий пример (думаем, вы и сами поймете, что он делает):
Теперь вы, вероятно, уже представляете, на что способны регулярные выражения.
### Действуйте умно
Умная маршрутизация, в частности обработка заголовки пакетов с использованием регулярных выражений, позволяет рулить трафиком так, как вам хочется. И это значительно упрощает ввод в строй нового кода – это просто, это не требует изменения самого кода, и при необходимости все можно быстро вернуть как было.
### Заинтересовались?
Загорелись желанием поэкспериментировать с Istio, Kubernetes и OpenShift на своем компьютере? Команда [Red Hat Developer Team](https://developers.redhat.com/about/) подготовила отличный [учебник](https://github.com/redhat-developer-demos/istio-tutorial) по этой теме и выложила в общий доступ все сопутствующие файлы. Так что вперед, и ни в чем себе не отказывайте.
Istio Egress: выход через сувенирную лавку
------------------------------------------
Применяя Istio вместе с Red Hat OpenShift и Kubernetes, можно значительно облегчить себе жизнь с микросервисами. Сервисная сетка Istio упрятана внутрь Kubernetes’овских pod’ов, а ваш код выполняется (в основном) изолированно. Производительность, простота изменения, трассировка и прочее – все это легко использовать именно за счет применения sidecar-контейнеров. Но что делать, если ваш микросервис должен общаться с другим сервисами, которые расположены за пределами вашей системы OpenShift-Kubernetes?
Здесь на помощь приходит Istio Egress. Если в двух словах, то он просто позволяет получить доступ к ресурсам (читай: «сервисам»), которые не входят в вашу систему Kubernetes’овских pod’ов. Если не выполнять дополнительную настройку, то в среде Istio Egress трафик маршрутизируется только внутри кластера pod’ов и между такими кластерами исходя из внутренних IP-таблиц. И такое закукливание прекрасно работает до тех пор, пока вам не нужен доступ к сервисам снаружи.
Egress позволяет обойти вышеупомянутые IP-таблицы, либо на основе правил Egress, либо для диапазона IP-адресов.
Допустим, у нас есть Java-программа, которая выполняет GET-запрос к httpbin.org/headers.
(httpbin.org – это просто удобный ресурс для тестирования исходящих сервис-запросов.)
Если ввести в командной строке `curl http://httpbin.org/headers`, мы увидим следующее:
Или можно открыть этот же адрес в браузере:
Как видим, расположенный там сервис просто возвращает переданные ему заголовки.
### Импортозамещаем в лоб
Теперь возьмем Java-код этого внешнего по отношению к нашей системе сервиса и запустим его у себя, где, напомним, стоит Istio. (Вы можете сделать это самостоятельно, обратившись к [нашему учебнику по Istio](https://github.com/redhat-developer-demos/istio-tutorial#egress).) Выполнив сборку соответствующего образа и запустив его на платформе OpenShift, мы вызовем этот сервис командой `curl egresshttpbin-istioegress.$(minishift ip).nip.io`, после чего увидим на экране вот что:
Опа, а что произошло? Всё же только что работало. Что значит Not Found? Мы же только что сделали для него `curl`.
### Расширяем IP-таблицы на весь интернет
Винить (или благодарить) за это надо Istio. Ведь Istio – это просто sidecar- контейнеры, который отвечают за обнаружение и маршрутизацию (ну и за массу других вещей, о которых мы рассказывали ранее). По этой причине IP-таблицы знают только о том, что находится внутри вашей системы кластеров. А httpbin.org расположен снаружи и, следовательно, недоступен. И вот тут на помощь приходит Istio Egress – без малейших изменений в вашем исходном коде.
Приведенное ниже Egress-правило заставляет Istio искать (если надо, то и во всем всемирном интернете) нужный сервис, в данном случае, httpbin.org. Как видно из этого файла (egress\_httpbin.yml), функциональность здесь довольно простая:
Осталось только применить это правило:
```
istioctl create -f egress_httpbin.yml -n istioegress
```
Просмотреть правила Egress можно командой `istioctl get egressrules`:
И наконец, опять запускаем команду *curl* – и видим, что все работает:
### Мыслим открыто
Как видите, Istio позволяет организовать взаимодействие и с внешним миром. Иными словами, вы можете всё так же создавать сервисы OpenShift и рулить ими через Kubernetes, держа всё в pod’ах, которые масштабируются вверх-вниз по мере надобности. И при этом вы спокойно можете обращаться к внешним по отношению к вашей среде сервисам. И да, еще раз повторимся, что все это можно делать, никак не трогая ваш код.
Это был последний пост из серии по Istio. Оставайтесь с нами – впереди много интересного! | https://habr.com/ru/post/487214/ | null | ru | null |
# Разработка ПО для лазерного толщинамера на FriendlyARM Smart210
Краткое описание: задача заключается в измерении сечения объекта между двумя движущимися лазерными датчиками, весь расчет происходит на стороне компьютера.
В качестве средства разработки была выбрана Qt в связи с тем, что это кросс-платформенный продукт, а также OpenSource. Qt устанавливалась последняя на тот момент версии 5.4. Первоначальное использование программы предполагалось под Windows OS с сенсорным экраном. Где то на середине пути решили переделать по Smart210.
Smart210 разработка наших китайских собратьев, с возможностью установки операционок (в комплекте): WinCE 6, Linux, Qtopia, Android. Также была опробована сборка Debian.
Целевой системой на данном устройстве первоначально была Linux. Работа с контроллером толщиномера осуществляется через FT2232HL.
Использование проприетарных драйверов FTDI имеет ряд этапов и особенностей:
Требуется отключение стандартных библиотек ftdi\_sio и usbserial:
```
sudo rmmod ftdi_sio
sudo rmmod usbserial
```
Это невозможно сделать без пере сборки ядра с включением этих библиотек в качестве модулей ядра.
Сборку ядра осуществлялась toolschain arm-linux- версии 4.5.1 входящей в комплект от производителя, попытка собрать ядро более новыми компиляторами приводило к неработоспособности сенсорного экрана, т. к. модуль friendlyarm-ts-mtinput (отвечающий за работу multi touch экрана) сваливался в ошибки, возможность пере сборки под новые компиляторы отсутствует (нет исходников).
В файле mini210\_linux\_defconfig, прописать путь к компилятору и настройку в качестве модулей ядра:
```
CONFIG_CROSS_COMPILE="arm-linux-"
...
CONFIG_USB_SERIAL=m
CONFIG_USB_SERIAL_FTDI_SIO=m
```
Хотя CONFIG\_USB\_SERIAL=m включает все зависимые библиотеки как модули ядра, в том числе и ftdi\_sio (на всякий случай CONFIG\_USB\_SERIAL\_FTDI\_SIO=m). Затем выполнить команду:
```
./build
```
Так как изменился состав модулей необходимо выполнить:
```
make modules
```
После чего остается скопировать в файловую систему. Сборка файловой системы утилитой yaffs2, входящей в комплект с диска, вызвала ошибку файла в момент установки. Пришлось использовать стандартную:
```
mkyaffs2 rootfs_rtm_210 rootfs_rtm_210.img
```
После проделанных манипуляций стало возможным использовать библиотеку FTDI.
Qt для работы в Linux брал версию 5.3.2 и собирал с поддержкой linuxfb.
Последующее использование такого подхода выявило недостаточную скорость прорисовки (не реагировал сенсорный экран при прорисовки). Использовался для прорисовки frame buffer, отсутствие поддержки OpenGL ES со стороны драйверов.
Остановился на Android, пришлось перерисовать переписать на использования ttyUSB, т. к. драйвер FTDI под Android существует лишь для Java.
При отключение и подключении FTDI обнаружилось появление 0х00 байта, что приводило к сдвигу, а при фиксированной длине данных в 10 байт и без признака начала пакета создавало неприятность. К тому же обрыв (как аварийная ситуация мог разбить пакет), решение искать первые 10 байт прошедших проверку на CRC8:
```
bool Controller::readBlockN(uchar *tmp, qint64 blockSize){
int bytesReceived = 0;
int bytesRead = 0;
qint64 m_blockSize = blockSize;
while (m_blockSize > 0) {
bytesReceived = read(uart0_filestream, ((void*)&tmp_block) + bytesRead, m_blockSize);
if (bytesReceived > 0){
m_blockSize -= bytesReceived;
bytesRead += bytesReceived;
if (bytesRead > 9) {
if (tmp_block[bytesRead - blockSize + 9] == getCRC8((uchar*)&tmp_block + bytesRead - blockSize, 9)){
memcpy(tmp, (uchar*)&tmp_block + bytesRead - blockSize, 10);
}
else{
m_blockSize = 1;
}
}
}
}
return true;
}
```
На этом этапе обнаружилось, что нет прав на использование портов ttyUSB\* и это происходит после каждой перезагрузки. Решение — вставить строку при загрузке программы:
```
system("su -c 'chmod 777 /dev/ttyUSB*'");
```
Оставалось убрать навигационную панель (максимально использовать экран, кроме того, предполагается, что данном устройстве не будут запускаться другие приложения). Стандартная панель не реагирует на события о скрытии и всегда находится поверх всех приложений. Решил просто её удалить:
```
system("su -c 'rm /system/app/SystemUI.apk'");
```
FriendlyARM имеет аккумулятор, что не сбрасывает время, но все же решил вызывать стандартные настройки даты времени Android при запуске приложения:
```
system("am start -n com.android.settings/.DateTimeSettingsSetupWizard");
```
Графика полностью прорисована в QgraphicsView:
Статус системы:
Ручной режим:
Автоматический режим:
Видео:
Изыскания и результаты:
Debian:
Громоздкая, занимает ~430Мб в чистом виде, есть поддержка OpenGL ES, используется драйвер mesa. Отсутствует поддержка multi touch экрана.
Qtopia:
Отсутствие поддержки OpenGL ES, да и сама она давно не поддерживается.
Linux (rootfs\_rtm\_210):
Отсутствие поддержки OpenGL ES, занимает очень мало место в чистом виде ~15Мб, с установленными всеми библиотеками от Qt ~90Мб, скорость загрузки операционки чуть больше 8 сек.
WinCE 6:
Не тестировал серьезно, всего лишь покопался в бинарном файле на упоминание об OpenGL ES, да и потребовало бы спорку под CE. Время поджимало принял решение отложить.
Android:
Поддерживает OpenGL ES, занимает ~215Мб, запускается около 2 минут. | https://habr.com/ru/post/248839/ | null | ru | null |
# Защита от spamGUARD v1.0
**Защита от spamGUARD v1.0**
*Боримся спамерами до конца*
Друзья, если честно устал чистить СПАМ комментариях, которые даже несмотря на защиту **Akismet** они пробиваются. Пришлось поставить более крутую **капчу**. Для тех кто в курсе, деятельность нашей команды именно декодирование капчи. По этому было решено поставить ReCaptcha: Особенность системы — текст не генерируется случайным образом, а берется из удаленной базы распознавания книг. Т.е. пользователь вводя код не только подтверждает что он человек, но и делает благое дело помогает распознавать сканированные книги.
У системы есть свой APIкод с помощью которого систему reCAPTCHA можно подключить к любому сайту. А так как у нас не обычный сайт ;), то на сайте имеется готовый плагин для Wordress. После установки плагин вам подскажет что нужно сгенерировать уникальные ключи для вашего блога, сделав это и немного настроив под себя ваш плагин уже готов к работе.
**Установка:**
`1. Скачать файл “recaptcha.zip” и загрузить содержимое в директорию “/wp-content/plugins/”.
2. Необязательно: Изменить конфигурационные настройки в файле по своим требованиям. В коде присутствуют комментарии для помощи.
3. Активировать плагин “reCAPTCHA” на странице управления плагинами в админ панели WordPress.
4. Произвести необходимые настройки конфигурации плагина “reCAPTCHA” на странице управления настройками в админ панели WordPress.` | https://habr.com/ru/post/43016/ | null | ru | null |
# Полезный тэг <label>
Тэг позволяет при щелчке по тексту передававать фокус ввода элементу типа :
`Имя:` | https://habr.com/ru/post/10639/ | null | ru | null |
# Vim по полной: Менеджер плагинов без фатальных недостатков
Оглавление
==========
1. [Введение](http://habrahabr.ru/post/259701/) (vim\_lib)
2. **Менеджер плагинов без фатальных недостатков** (vim\_lib, vim\_plugmanager)
3. [Уровень проекта и файловая система](http://habrahabr.ru/post/259995/) (vim\_prj, nerdtree)
4. [Snippets и шаблоны файлов](http://habrahabr.ru/post/260591/) (UltiSnips, vim\_template)
5. [Компиляция и выполнение чего угодно](http://habrahabr.ru/post/261179/) (vim-quickrun)
6. [Работа с Git](http://habrahabr.ru/post/261783/) (vim\_git)
7. [Деплой](http://habrahabr.ru/post/263487/) (vim\_deploy)
8. [Тестирование с помощью xUnit](http://habrahabr.ru/post/264297/) (vim\_unittest)
9. [Библиотека, на которой все держится](http://habrahabr.ru/post/264351/) (vim\_lib)
10. Другие полезные плагины
Я пользовался, наверно, всеми популярными менеджерами плагинов для Vim и у меня не было ни малейшего желания писать свой собственный, так как эти меня вполне устраивали, но было небольшое но, о котором я расскажу в этой статье.
~~Плохие~~ Другие менеджеры
===========================
Как работает менеджер плагинов для Vim? Все тривиально. Во время старта редактора считывается *.vimrc* в котором объявляются все используемые в данный момент плагины. Эти имена конкатенируются с адресом каталога, который должен хранить плагины и полученные строки добавляются в *runtimepath* — переменная Vim, которая определяет, откуда редактору брать стартовые скрипты, плагины и все остальное.
Основной проблемой большинства популярных менеджеров плагинов для Vim является то, что они заполняют переменную *runtimepath* как попало. К чему это ведет? Плагины загружаются беспорядочно, нет возможности переопределить настройки плагина для конкретного проекта, плагины переопределяют ваши собственные настройки Vim и т.д. Все еще больше усугубляется невозможностью контролировать порядок загрузки плагинов, когда нужно сначала загрузить плагин A, а только затем зависимый от него благин B. Одним словом — боль.
Что нам нужно в идеале
======================
Я уже говорил раньше и подробнее остановлюсь на этом вопросе в следующей статье, а сейчас только немного коснусь его. Предлагаемая мной структура добавляет еще один уровень инициализации редактора Vim. Это означает, что ваши Vim-конфигурации и плагины будут существовать на трех уровнях:
1. Системном (*$VIMRUNTIME/*) — конфигурации и плагины, которые распространяются на всех пользователей системы
2. Пользовательские (*~/.vim/*) — конфигурации и плагины конкретного пользователя
3. Проектные (*./.vim/*) — конфигурации и плагины, доступные только в данном проекте. Именно этого уровня нет в Vim, точнее он есть, но реализован довольно слабо
Это позволит, например, настроить шаблоны для Java классов, а затем переопределить их для конкретного проекта. Можно так же установить некоторый плагин только для определенного проекта, и этот плагин не будет подгружаться Vim в других проектах, что сэкономит память и увеличит производительность редактора (например вы решили начать работать с Lua и не хотите ставить плагины в *~/.vim/*). Только представьте, один редактор на все случаи жизни и никаких лагов.
Стандарты плагинов
==================
Библиотека vim\_lib определяет как структуру плагинов Vim (но не ограничивает вас только этой структурой, может использоваться любой плагин), так и порядок их подключения и загрузки, для этого реализованы классы *sys/Plugin* и *sys/Autoload* соответственно.
Если реализовать плагин в строгом соответствии с требованиями класса *sys/Plugin*, то мы получим следующую структуру:
```
myPlugin/
plugin/
myPlugin.vim
autoload/
...
myPlugin.vim
doc/
myPlugin.rux
```
Файл *plugin/myPlugin.vim* содержит логику инициализации и подключения плагина.
**Пример**
```
" Date Create: 2015-02-23 22:45:56
" Last Change: 2015-06-07 18:21:15
" Author: Artur Sh. Mamedbekov (Artur-Mamedbekov@yandex.ru)
" License: GNU GPL v3 (http://www.gnu.org/copyleft/gpl.html)
" Аналог use в VimLanguage
let s:Plugin = vim_lib#sys#Plugin#
let s:System = vim_lib#sys#System#.new()
let s:p = s:Plugin.new('vim_write', '1') " Создание объекта плагина с указанием его имени и версии
" Опции плагина
"" {{{
" @var bool Следует ли выполнять замену ключевых значений в файле перед сохранением.
"" }}}
let s:p.preplace = 1
"" {{{
" @var bool Включен ли механизм автосохранения изменений.
"" }}}
let s:p.aw = 0
"" {{{
" @var string|array Массив, содержащий имена типов файлов, для которых задействован механизм автосохранения изменений. Если опция установлена в значение 'all', механизм задействован для всех типов файлов.
"" }}}
let s:p.awTypes = 'all'
if !exists('g:vim_write#replacement')
"" {{{
" @var hash Словарь замен, используемый перед записью буфера для замены ключевых слов. Словарь имеет следующую структуру: {типФайла: [regexp, ...]}. Тип 'all' используется для всех файлов.
"" }}}
let g:vim_write#replacement = {}
endif
" Функция инициализации плагина, в ней можно писать любую логику
function! s:p.run() " {{{
call s:System.au('BufWritePre,FileWritePre', function('vim_write#_writePre'))
call s:System.au('CursorHold', function('vim_write#_autowrite'))
endfunction " }}}
" Объявление пунктов меню плагина. Они попадут в Plugins.имяПлагина.пунктМеню
call s:p.menu('Aw_start', 'awstart', '1')
call s:p.menu('Aw_stop', 'awstop', '2')
" Объявление команд плагина
call s:p.comm('VimWriteAwStart', 'awstart()')
call s:p.comm('VimWriteAwStop', 'awstop()')
call s:p.reg() " Регистрация плагина, которая делает его доступным в редакторе
```
Файл *autoload/myPlugin.vim* содержит методы плагина. Опытные пользователи Vim сразу заметят, что основной код плагина будет подгружаться при первом его использовании, а не во время запуска редактора. Делается это через глобальный вызов методов плагина. На пример, при выполнении команды *VimWriteAwStart* из предыдущего примера, будет вызван метод *имяПлагина#awstart()*.
**Пример**
```
" Date Create: 2015-02-23 22:48:37
" Last Change: 2015-06-07 18:21:15
" Author: Artur Sh. Mamedbekov (Artur-Mamedbekov@yandex.ru)
" License: GNU GPL v3 (http://www.gnu.org/copyleft/gpl.html)
" Аналог use в VimLanguage
let s:Publisher = vim_lib#sys#Publisher#.new()
let s:Content = vim_lib#sys#Content#.new()
"" {{{
" Метод активирует механизм автосохранение.
"" }}}
function! vim_write#awstart() " {{{
let g:vim_write#.autowrite = 1
endfunction " }}}
...
```
Файл *doc/myPlugin.rux* содержит документацию к плагину.
Зачем все это нужно? Во-первых стандартизация. Писать, изменять и разбираться в плагинах становится легче. Во-вторых их проще отключить.
Подробнее можно почитать [здесь](https://github.com/Bashka/vim_lib/blob/master/doc/vim_lib.rux#L869).
Автозагрузка
============
Класс *sys/Authoload* библиотеки определяет порядок инициализации как самого редактора Vim, так и его плагинов. Инициализация выполняется в несколько этапов:
1. Подключение основных файлов конфигурации редактора (*$VIMRUNTIME*)
2. Подключение общесистемных плагинов (*$VIMRUNTIME/plugin/*)
3. Подключение файло-зависимых конфигураций (*$VIMRUNTIME/ftplugin/*)
4. Подключение основных файлов конфигурации пользователя (*~/.vimrc*)
5. Подключение пользовательских плагинов (*~/.vim/plugin/*)
6. Подключение файло-зависимых плагинов пользователя (*~/.vim/ftplugin/*)
7. Подключение основных файлов конфигурации проекта (*./.vimrc*)
8. Подключение проектных плагинов (*./.vim/plugin/*)
9. Подключение файло-зависимых плагинов проекта (*./.vim/ftplugin*)
Выполняется это с помощью уже знакомой нам переменной *runtimepath*, но учитывается порядок загрузки плагинов, их локализация (системные, пользовательские или проектные), а так же поддерживается механизм переопределения конфигураций как редактора, так и любых плагинов на каждом из уровней (проектный уровень самый приоритетный).
Вообще класс *sys/Authoload* позволяет реализовать любую иерархию вложенности и приоритет конфигураций, а не только трехступенчатую, но я не увидел необходимости добавлять новые уровни.
Для использования автозагрузки, предлагаемой классом *sys/Authoload*, достаточно добавить в ваш файл *.vimrc* следующие строки:
```
filetype off
set rtp=~/.vim/bundle/vim_lib
call vim_lib#sys#Autoload#init('~/.vim', 'bundle') " Адрес до вашего ~/.vim/bundle
Plugin 'vim_lib'
" Другие плагины
filetype indent plugin on
```
Сделать это можно не только на пользовательском уровне (*~/.vimrc*), но и на системном (*$VIMRUNTIME/.vimrc*) или проектном (*./.vimrc*), при этом логика автозагрузки будет распространятся только от данного уровня и «ниже». На всех низлежайших уровнях достаточно просто подключать новые плагины, доступные только этому уровню:
```
filetype off
call vim_lib#sys#Autoload#init('.vim', 'bundle') " Подключение плагина на проектном уровне
Plugin 'myPlugin'
filetype indent plugin on
```
Для отключения плагина, достаточно просто закоментировать строку *Plugin 'имя'*.
Сконфигурировать плагин можно прямо во время его подключения:
```
Plugin 'vim_deploy', {
\ 'options': {'adapter': 'shipit'}, " Переопределение опций плагина
\ 'map': {'deploy': 'd'}, " Переопределение горячих клавиш
\}
```
На более низких уровнях можно переопределить эти конфигурации:
```
let g:vim_deploy#options = {'adapter': 'gradle'}
```
Все очень гибко и удобно.
Менеджер плагинов
=================
Казалось бы, что мешает заставить другие менеджеры плагинов устанавливать плагины в нужные нам каталоги (системный, пользовательский или проектный)? Проблема здесь в том, что другие менеджеры не просто устанавливают сторонние плагины, но и определяют порядок из инициализации, а нам это не нужно (уже реализовано классом *sys/Authoload* библиотеки). Та самая проблема несовместимости Vim плагинов, о которой я говорил в предыдущей статье. Пришлось писать свое решение.
[vim\_plugmanager](https://github.com/Bashka/vim_plugmanager) имеет довольно простой интерфейс и позволяет устанавливать плагины из GitHub в системный каталог, каталог пользователя или проектный каталог, в зависимости от того, где вы сейчас находитесь.
**Окно со списком плагинов**
Как видно на рисунке, vim\_plugmanager реализован в виде окна, в котором он отображает список установленных на данный момент плагинов (именно установленных, а не подключенных) с группировкой по уровням. Для добавления нового плагина достаточно нажать клавишу *a*, а для удаления навести курсор на плагин и нажать *dd* (очень привычно, не так ли?).
После установки нового плагина его необходимо подключить. Для этого, как уже было сказано выше, достаточно добавить в текущий *.vimrc* (текущего уровня) запись *Plugin 'имяПлагина'*. Нужно это потому, что установка плагина представляет собой копирование его в каталог с плагинами, а подключение добавляет его в *vimruntime*, после чего он может быть загружен редактором.
Подробнее можно почитать [здесь](https://github.com/Bashka/vim_plugmanager/blob/master/doc/vim_plugmanager.rux).
Пока все
========
В этой статье я осветил далеко не все проблемы, с которыми я столкнулся при использовании плагинов Vim, а так же не все возможности описанных решений. Не думаю, что стоит копировать документацию, когда она доступна в общем доступе.
Возможно, я мог обойтись уже имеющимися решениями, скрестив их между собой, но в этом случае был риск потратить намного больше времени, а в результате получить не то, что мне было нужно. | https://habr.com/ru/post/259725/ | null | ru | null |
# Колокол — система событий в Go или очередная event-system библиотека
В работе над одним проектом в компании NUT.Tech нам понадобилась система событий, работа которой не влияла бы на основной поток выполнения программы.
Требования к системе были довольно простыми:
* Возможность подписываться на события,
* Возможность уведомлять систему о событии,
* Возможность передавать в обработчики событий дополнительную информацию,
* Простая реализация обработчиков событий,
* Выполнение обработчиков событий не должно никак аффектить основной поток программы.
Какое-то время мы пытались найти подходящую нам библиотеку в интернете. “Наверняка, мы не первые, кто столкнулся с необходимостью такого функционала у себя в приложении” - думали мы. И, действительно, мы нашли довольно много пакетов со схожей функциональностью. Ниже перечислю некоторые из рассмотренных нами библиотек:
* <https://github.com/ReactiveX/RxGo> - популярная библиотека, обладающая нужной нам функциональностью, но эта функциональность только малая часть того, что это библиотека умеет. А нам очень не хотелось использовать что-то большое ради одной небольшой функции. Это похоже на забивание гвоздей микроскопом.
* <https://github.com/gookit/event> - показалась нам переусложненной.
* <https://github.com/agoalofalife/event> - не умеет запускать обработчики в отдельном потоке.
* <https://github.com/AlexanderGrom/go-event> - также не умеет запускать обработчики в отдельном потоке. Зато нам понравилась легковесность библиотеки и простой интерфейс.
Остальные найденные нами библиотеки были или очень объемные, с большим количеством настроек (а нам хотелось что-то простое и легкое), либо давно не обновлялись, либо работали в том же потоке, что и основная программа.
В общем, так и не сумев найти отвечающую всем нашим требованиям библиотеку, мы решили, что проще и быстрее будет написать все самим (какая редкость для Golang, да?).
Сначала мы добавили нашу систему событий как часть основного приложения, но с требованием “в будущем должно быть легко выделить код в отдельный пакет”. На написание непосредственно кода и тестов к нему ушло несколько дней.
Ниже расскажу и покажу на примерах, что у нас получилось.
Библиотека написана на языке Go и представляет из себя простейшую систему событий, которая основана на выполнении обработчиков независимо от основного потока.
Особенностями библиотеки являются:
* Нет зависимостей от сторонних библиотек,
* Возможность добавить несколько обработчиков одного или нескольких событий,
* Каждый обработчик события запускается в отдельной горутине, обработчики выполняются независимо от основного потока,
* Возможность передавать любые пользовательские данные в обработчики событий,
* Полное покрытие тестами.
Исходный код и примеры можно посмотреть по ссылке <https://github.com/nuttech/bell>.
Использование библиотеки
------------------------
Для добавления пакета в приложение достаточно выполнить команду
```
go get -u github.com/nuttech/bell
```
и далее в нужном файле проимпортировать ее:
```
import "github.com/nuttech/bell"
```
Чтобы добавить обработчик того или иного события, вам нужно добавить следующий код:
```
bell.Listen("event_name", func(message bell.Message) {
// здесь код вашего обработчика
})
```
Первый аргумент функции - это название события, им может быть любая строка. Например, для вызова события успешной авторизации пользователя можно использовать название “`user_login_success`”.
Второй аргумент функции Listen - это функция, которая на вход принимает структуру `bell.Message`. Это и есть ваша функция-обработчик события. В структуре `bell.Message` будет передана системная информация и пользовательские данные:
```
type Message struct {
Event string // название события
Timestamp time.Time // время вызова события
Value interface{} // пользовательские данные
}
```
Так как Message.Value - это interface{}, туда можно передать что угодно: идентификатор, строку, структуру и т.д.
Обработчиков события можно добавлять сколько угодно много. Все они будут вызваны в отдельной горутине:
```
bell.Listen("event_name", func(message bell.Message) {
// первый обработчик
})
bell.Listen("event_name", func(message bell.Message) {
// второй обработчик
})
```
Для того, чтобы вызвать событие и запустить обработчики, достаточно добавить примерно такой код:
```
bell.Call("event_name", "some data")
```
где первый параметр - это название события, а второй - пользовательские данные, которые вы захотите передать в обработчики.
Например, если у вас есть структура userStruct и вызов события выглядит следующим образом:
```
type userStruct struct {
Name string
}
bell.Call("event_name", userStruct{Name: "Jon"})
```
То обработчик может может быть таким:
```
bell.Listen("event_name", func(message bell.Message) {
user := message.Value.(userStruct)
fmt.Printf("%#v\n", userStruct{Name: "Jon"}) // main.userStruct{Name:"Jon"}
})
```
### Вспомогательные функции
Пакет также содержит еще несколько вспомогательных функций:
#### bell.List()
Функция вернет список всех событий, на которые добавлены подписчики.
#### bell.Has("event\_name")
С помощью этой функции можно проверить, существуют ли обработчики для указанного события.
#### \_ = bell.Remove()
А эта функция удалит все обработчики всех событий.
#### \_ = bell.Remove("event\_name")
Если передать в функцию `bell.Remove` название события, то будут удалены только обработчики переданного события.
### Полный пример работы пакета
Напоследок приведу простой пример использования Bell. В коде для понимания происходящего добавлены комментарии.
Пример использования библиотеки Bell
```
package main
import (
"fmt"
"github.com/nuttech/bell"
"log"
"net/http"
"net/url"
"time"
)
const requestEvent = "request"
const loginSuccessEvent = "login_success"
type LoginRequest struct {
Method string
Path string
UserAgent string
}
type User struct {
Login string
}
func main() {
// создаем обработчик события request, который будет выводить информацию о запросе
bell.Listen(requestEvent, func(message bell.Message) {
time.Sleep(time.Second * 2)
r := message.Value.(LoginRequest)
log.Printf("%s %s, %s", r.Method, r.Path, r.UserAgent)
})
// Создаем два обработчика события успешного логина
// Первый будет писать локальный лог
bell.Listen(loginSuccessEvent, func(message bell.Message) {
data := message.Value.(User)
log.Printf("%#v\n", data)
})
// Второй будет отправлять данные на какой-то сторонний сервис
bell.Listen(loginSuccessEvent, func(message bell.Message) {
userData := message.Value.(User)
rData := url.Values{
"login": {userData.Login},
}
// шлем запрос локально для упрощения примера
, = http.PostForm("http://localhost:8888/log", rData)
})
// Создадим обработчик запроса на запись лога
http.HandleFunc("/log", func(writer http.ResponseWriter, request *http.Request) {
log.Println("Save login request")
request.ParseForm()
fmt.Printf("%#v\n", request.PostForm)
})
http.HandleFunc("/login", func(writer http.ResponseWriter, request *http.Request) {
r := LoginRequest{
Path: request.RequestURI,
Method: request.Method,
UserAgent: request.UserAgent(),
}
// Вызываем событие request и продолжаем работу обработчика
_ = bell.Ring(requestEvent, r)
// получаем логи и пароль
request.ParseForm()
login := request.FormValue("login")
pass := request.FormValue("password")
if login != "login" || pass != "pass" {
writer.WriteHeader(http.StatusUnauthorized)
return
}
// вызываем событие успешного логина
_ = bell.Ring(loginSuccessEvent, User{Login: login})
// и сразу отдаем клиенту 200 ответ
writer.WriteHeader(http.StatusOK)
})
log.Fatal(http.ListenAndServe(":8888", nil))
}
```
Заключение
----------
В итоге, у нас получилась легкая и простая библиотека, которая отвечает всем нашим требованиям. Теперь она используется в наших проектах.
Мы будем рады любым замечаниям и предложениям по доработке данной библиотеки. | https://habr.com/ru/post/651453/ | null | ru | null |
# Я перешел на Ubuntu и не… жалею?
Пост ненависти. К мирозданию в целом и к своей карме что ли.
В общем, достался мне компик. Dell PowerEdge 400SC (Service Tag: 2KF6641). И решил я его подключить к телевизору, потому что мне казалось, что это единственный способ посмотреть флеш-контент на телеке.
*Кстати, отличное лирическое отступление. На дворе 2013 год. У меня дома есть MacBook (поздний 2007), iPad, два iPhone-a, Samsung Smart TV, Apple TV. И есть вебсайт, который эксклюзивно (все понимают, что это значит, да?) вещает некий спортивный контент. Т.е. соревнования можно посмотреть только на этом сайте. На сайте есть только набор роликов flash – часть из них записана, часть стримит мероприятия в реальном времени. Надеюсь понятно. Приложений для мобильных устройств нет – т.е. айфоны и айпады идут лесом. Стриминга нет, т.е. умный ТВ идет лесом. На макбуке смотреть можно, но так как он 2007 года, он не умеет пробрасывать видео на эппл ТВ, т.е. макбук идет лесом. В итоге, макбук – единственное устройство, способное воспроизвести этот контент. В поддержке отвечают просто – вы когда платили деньги за наши услуги, соглашались с правилами их оказания. Вот просто лолшто какое-то.*
Итак, появился у меня комп. Нормальный такой комп – я туда 2 гига памяти засунул, загрузил XP, запустил хром и убедился, что контент показывается. Дело за малым – вывести это все на телек. Есть проблема – выход у видеокарточки один (ATI Rage XL). И еще одна – надо отдать диск с XP старому хозяину. Ну и соответственно что-то поставить вместо XP. Пошел спросил у ребят – ставь, говорят XBMCbuntu. Ну ок, че ее ставить-то. Создал флешку, загружаюсь. Загрузка идет до тех пор, пока комп не переключается в графический режим, после чего монитор тупо отрубается. Пошел в интернет, там говорят – а, кстати, да, старые ATI-шные карточки не поддерживаются, дропнули саппорт. Ну и фиг с ними, все равно карточка одноголовая и не то, что мне нужно. Пошел на ебай да купил за 6 долларов nVidia GeForce FX 5950 ultra. Там и DVI выход есть, и с дровами проблем, казалось бы, быть не должно.
Приехала карточка. Загрузился в XP, подключил комп к телеку кабелем DVI<->HDMI. Тишь да гладь, да божья благодать. Т.е. нет на телеке ничего, не показывает. Примерно день ужимок и прыжков с дровами, вспоминаются уже потихоньку лохматые года и осознание того, что мол да, забыл я уже как это – второй монитор подключать. Перезагрузки, форс-детекты, RivaTuner, nVidia TV Tool – и ничего. Стал грешить на кабель — но подключил другим DVI кабелем второй монитор, он благополучно нашелся, я нагорячую выдернул кабель от второго монитора и воткнул кабель от телека – на телека была прекрасная хайрез картинка. Т.е. хард весь прекрасно работает – просто телек не признается видюхе, что он вполне даже может. Ну нет в XP возможности сказать дровам – эй, ребята, ну-ка гоним-ка картинку такого-то разрешения в DVI выход и будь что будет. Слишком умные все.
Ну так я на XP и не надеялся. Ставим XBMCbuntu, грузимся, вуаля – на главном мониторе появилось изображение, карточка работает в графическом одноголовом режиме. Ищем настройки мультимониторности – нет таких. Телек не детектится. Начинаем делать то, ради чего все и затевалось – гранулярный контроль оси, возможность одной строчкой в конфигах телепортировать массивные объекты и поворачивать время вспять.
Попытка первая – сказать дровам XBMCbuntu принудительно слать картинку в DVI. Ищем и находим информацию в инете о том как это сделать. Надо добавить опцию «ConnectedMonitor» «DFP» в файле /etc/X11/xorg.conf. Все оказалось просто.
Только нет такого файла в XBMCBuntu. Был, потому что на всех форумах на него есть референсы, но в какой-то момент его дропнули. Попытки создать свой файл привели к тому, что графический режим просто отвалился, и после загрузки монитор вырубался.
А нафик мне этот XBMCbuntu, если я могу накатить Ubuntu и поверх нее запускать тот же xbmc? Но у меня хоть будет нормальная необрезанная ось с software center, где я смогу ставить всякие дрова просто написав в строке поиска “drivers”, подумал я.
Начинаем ставить убунту. Доходим в процессе установки до партирования диска, создаем все партиции, выбираем диск для установки, нажимаем кнопку далее и за те три-четыре секунды, что проходят между действием пользователя и реакцией загруженной с USB-флэшки оси, успеваем увидеть, что есть еще дропдаун для выбора куда писать бут-сектор и в этом дропдауне выбран совсем не тот диск, на котором мы выбрали партицию, а маленкий диск с установленной XP. Кнопка «назад» в установщике есть, но она безнадежно задисейблена. Для спасения диска с XP, вырубаем комп с кнопки, начинаем процедуру заново. А это все меееееедлееено. Ребят, очень медленно. 10-15 минут сначала до момента начала установки – легко. А уже ночь. Уже спать охота, состояние полного отупения. Короче повторяем ту же самую ошибку (блин, ведь знал же уже про эту подставу! Ну как так можно?!?!?), а способа отменить, откатить, вернуть взад – нету. Опять перезагружаемся, еще 15 минут. Вроде все перепроверил, назанчил точки монтирования уже созданным партициям. Жмем далее. Убунта ругается, что некоторые разделы не были выбраны для форматирования. И зависает. Еще 15 минут и вроде пошла установка. Я уже даже не злой, время полвторого ночи, меня уже колбасит, но я надеюсь, что все заработает и я хотя бы лягу спать в нормальном настроении.
Все, прошла установка, я загружаюсь и вижу… черный экран с курсором мыши на нем. Ну жду какое-то время, но очевидно что все, загрузка окончилась. Лезу в инет, нахожу гениальное: «This usually happens because you have an Nvidia or AMD graphics card» (http://askubuntu.com/questions/162075/my-computer-boots-to-a-black-screen-what-options-do-i-have-to-fix-it).
Чуваки, серьезно. This usually happens because you have an Nvidia or AMD graphics card. А с какими картами проблем нет? Со встроенной графой от интела? Матрокс мультиголовый купить? Или сдуть пыль с 3dfx Voodoo?
Ну ок, пытаюсь что-то сделать с драйвером. ФАКи, аскубунту и прочее. Нахожу вроде утилиту для обновления дров – jockey-text (почему? Почему она называется jockey-text?). Вижу в ней возможность выбрать драйвер, выбираю вместо опен-сорсового драйвера nVidia-евский, перезагружаюсь. Вижу nVidia-евский сплэшскрин, т.е. мы уверенно работаем в графическом режиме! После этого монитор гаснет. Терминалы (ctrl+alt+f2) перестают отвечать, т.е. машина глухо висит. И сил уже нет, иду спать в полтретьего ночи.
К чему я все это пишу? Ребят, я преклоняюсь перед линуксом. С нуля сделать такое. Просто усилиями сообщества! Обожаю ломать свои роутеры, учусь, не сдаюсь сразу, не пытаюсь ожидать от линукса виндового поведения и стараюсь постигнуть юникс-вэй. Но, блин, это же ад. Когда ты выгружаешь оконный менеджер или графическую среду, не знаю как она точно называется, и после этого ты не можешь ее включить обратно, потому что она вроде запущена, но в списке процессов ее нет (http://askubuntu.com/questions/77330/lightdm-will-not-start-after-stopping-it, человек пишет: [UPDATE: I appreciate the suggestions you posted, but since I couldn't make anything work in the end, I ended up re-installing Ubuntu a little while ago.]). Понимаете, винда хотя бы загружается до рабочего стола и я могу запустить браузер и поискать информацию в инете. А что делать в убунте? Ставить lynx и в текстовом режиме искать решения проблем?). И вы предлагаете поставить мне Ubuntu на комп моей маме? В моем случае она даже конца установки не дождется. А ну-ка проблема – как решать?
В общем я зол. Я, конечно, понимаю, что haters gonna hate, что то, что я сейчас делаю, называется хабра-суицидом, и прочее прочее прочее. Но, блин, нельзя пихать убунту на десктоп обывателю. Пройдут еще века, прежде чем она превратится из нашей гиковской няшки в домохозяешную ось. Потому что никогда вы не объясните человеку, что для того, чтобы изменить настройки видеокарты, надо сделать вот это:
```
sudo apt-get install python-software-properties pkg-config
sudo add-apt-repository ppa:ubuntu-x-swat/x-updates
sudo apt-get update
sudo apt-get install nvidia-current nvidia-settings
```
А потом, когда все-таки объясните, он сделает то, что вы ему сказали, сделает sudo nvidia-settings, а та ему скажет, что ты, мол, друг, используешь неродной драйвер, запусти-ка nvidia-xconf. А этого nvidia-xconf – нету. Ни в apt-get, и нигде вообще, а если его найти или написать самому, он ругнется на что-нибудь еще, и так до бесконечности. Или в мастере создания партиций ты, как тебе и завещали, создаешь отдельные партиции для /, /usr, /var, /home, жмешь далее а тебе говорят – э, друг, всего гиг для /usr? Мало, накинь хотя бы до двух. И ты идешь и не накидываешь, а создаешь новую партицию, если у тебя осталось место в конце диска, потому что заресайзить этот мастер не дает и теперь у тебя гиг неотпартированного мест где-то в середине диска. Ну или ты сидишь и партируешь все заново. На оси, загруженной с флэшки. Ну что, сразу нельзя было сказать – чувак, ты содаешь слишком маленькую партицию! Ну мы же все знаем – вот у тебя в диалоге и размер партиции, и точка монтирования – ну почему сразу не посмотреть?!?!?
Ну вот и как вообще я могу раскрывать рот и рекомендовать кому-то попробовать убунту и линукс, если я со своим почти двадцатилетним стажем работы с компом смог не больше, чем довести комп до состояния овоща?
В общем я очень грущу сегодня и решил поделиться с вами. ~~Прощай, хабр.~~
Update:
Восьмерка не встала — после загрузки с USB-диска показывает логотип Windows в течение 5 минут, после чего демонстрирует на экране код 0x0000000A (IRQ\_NOT\_LESS\_OR\_EQUAL)
Семерка не умеет вставать на USB-диски. Попробовать не-USB-диск у меня пока возможности нет. Но инсталлятор стартует бодренько, надежда есть.
Update 2: [habrahabr.ru/post/202146](http://habrahabr.ru/post/202146/) | https://habr.com/ru/post/202056/ | null | ru | null |
# Генерация PDF из WPF-приложения «для всех, даром, и пусть никто не уйдет обиженный»
Пару недель назад на проекте появилась задача генерации PDF.
Разумеется, я, как разработчик WPF UI, сразу был против сурового подхода кодирования отрисовки всех примитивов PDF в коде C#.
И заказчик был непротив покупки некоего платного конвертера из HTML в PDF, например.
Вроде бы все просто — генерируем строку с HTML-разметкой, используя DotLiquid для шаблонизации, и конвертируем в PDF с помощью одного из множества платных конвертеров.
Единственная засада — плохая совместимость HTML со страничной структурой PDF-документа.
Только я начал закапываться в поисках решения этой проблемы, как один коллега поделился ссылкой на [статью с альтернативным решением](http://www.nathanpjones.com/wp/2013/03/output-to-pdf-in-wpf-for-free/).
Из статьи я узнал, что есть возможность сгенерировать PDF из XPS-документа (этот формат поддерживается в WPF FlowDocument).
К тому же, для генерации использовалась бесплатная библиотека PDFSharp.
Исходники можете [скачать с GitHub](https://github.com/homoluden/WPF2PDF).
**UPD**: *уже не первый раз наблюдаю как статью плюсуют (первые минусы были сразу после публикации и вряд ли относятся к основному контенту), при этом сливая карму. Мне интересна мотивация, обратная связь. Отпишитесь, кто чем недоволен / доволен, если не затруднит.*
#### Дисклеймер
Представляемые Вашему вниманию исходные коды не представляют собой примера для подражания. Чтобы не затягивать со статьей, я не стал следовать каким бы то ни было паттернам проектирования. В исходниках простой «Code Behind» подход. Это сделано еще и для простоты восприятия сути, т.е. для фокусировки на самой генерации PDF. Думаю вы легко сможете интегрировать основные куски кода в структуру Вашего проекта.
Так же в исходниках Вы встретите массивное использование **dynamic** в качестве источника данных для шаблона DotLiquid. Это тоже было сделано в основном для простоты и скорости. [На сайте DotLiquid](https://github.com/formosatek/dotliquid/wiki/DotLiquid-for-Developers) есть описание как аннотировать Ваши собственные классы, чтобы они могли быть использованы в шаблоне. Тут Вы тоже легко сможете адаптировать мои исходники под свои нужды.
Ну и еще стоит упоминуть, что у PDFSharp мной была обнаружена проблема с псевдо-шрифтами FlowDocument / XPS. В частности, отрендеренные маркеры ненумированного списка из XPS экспортуруются в PDF в виде пустых квадратиков. В режиме дебага я получал сообщения Debug.Assert(...) с ошибкой импортирования / экспортирования шрифтов. Эту проблему пока не исследовал. Проблему со списками легко обойти с помощью шаблона.
#### Подготовка
Ниже представлен список необходимых манипуляций:
* Идем на [сайт про модифицированный PDFSharp](http://www.nathanpjones.com/wp/2013/03/output-to-pdf-in-wpf-for-free/) и качаем оттуда скомпилированные сборки либо сами исходники. Альтернативой может служить PDFSharp версий 1.2 — 1.31, включительно.
* Устанавливаем библиотеку DotLiquid (версия 1.7.0 на момент написания статьи) с помощью NuGet (установите Nuget, если еще не сделали этого)
* Добавьте ссылки на сборки **System.Printing** и **ReachFramework** к проекту, в котором будет производится генерация PDF
#### Главное окно
Ниже представлена разметка главного окна.
```
<Setter Property="FontSize" Value="14"/>
<Setter Property="Margin" Value="5"/>
Parse
Print
```
Здесь мы видим **FlowDocumentReader**, который будет отображать отрендеренный FlowDocument. В разметке Вы также можете видеть захардкоженый FlowDocument, который я использую для создания шаблона с помощью дизайнера в Visual Studio.
Также Вы можете видеть, что я использую обычные контролы и стили WPF. В этом один из огромных бонусов использования FlowDocument для генерации PDF. Я могу использовать контролы и ресурсы стилей своего WPF приложения. Для подхода с HTML в качестве посредника пришлось бы отдельно поддерживать сборку CSS стилей и кусков HTML, которые еще как-то необходимо будет внедрить в шаблон.
#### Контекст данных для шаблона
Для генерации контекста данных я добавил в Code Behind главного окна приватный метод, в котором захардкожено создание DotLiquid.Hash для dynamic-объекта.
```
private DotLiquid.Hash CreateDocumentContext()
{
var context = new
{
Title = "Hello, Habrahabr!",
Subtitle = "Experimenting with dotLiquid, FlowDocument and PDFSharp",
Steps = new List{
new { Title = "Document Context", Description = "Create data source for dotLiquid Template"},
new { Title = "Rendering", Description = "Load template string and render it into FlowDocument markup with Document Context given"},
new { Title = "Parse markup", Description = "Use XAML Parser to prepare FlowDocument instance"},
new { Title = "Save to XPS", Description = "Save prepared FlowDocument into XPS format"},
new { Title = "Convert XPS to PDF", Description = "Convert XPS to WPF using PDFSharp"},
}
};
return DotLiquid.Hash.FromAnonymousObject(context);
}
```
Как я написал в дисклеймере, это просто пример. В реальном проекте у Вас должен быть некий конвертер для реальных DTO или ViewModel.
В мануале для разработчика [на странице DotLiquid](https://github.com/formosatek/dotliquid/wiki/DotLiquid-for-Developers) написано, что в шаблоне нельзя просто так использовать экземпляр некоего произвольного класса для вывода строкового значения. Если Вы в шаблоне пропишете вывод, например, объекта DateTime, то в отрендеренный документ попадет просто вывод ToString() без параметров. А вот если шаблону подвернется созданный Вами объект, например какой-нибудь *BlaBlaUser*, то DotLiquid вместо него выведет строку с ошибкой. И это, кстати, очень хорошо, т.к. Вы сразу увидите конкретное место где Вы ошиблись, при этом все равно шаблон будет отрендерен.
#### Шаблон
```
<Setter Property="FontSize" Value="14"/>
<Setter Property="Margin" Value="5"/>
<Setter Property="TextWrapping" Value="Wrap"/>
{{ Title }}
{{ Subtitle }}
Steps to generate PDF:
{% for step in Steps -%}
{% endfor -%}
```
Имейте в виду, вместо вставки биндинга к контексту DotLiquid напрямую в аттрибуте TextBlock.Text надежнее будет использовать вложенный блок CDATA:
```
{{ step.Title }}
```
Это обезопасит Вас от символов, несовместимых с XML-форматом.
#### Рендеринг и парсинг FlowDocument
```
private void ParseButton_OnClick(object sender, RoutedEventArgs e)
{
using (var stream = new FileStream("Templates\\report1.lqd", FileMode.Open))
{
using (var reader = new StreamReader(stream))
{
var templateString = reader.ReadToEnd();
var template = dotTemplate.Parse(templateString);
var docContext = CreateDocumentContext();
var docString = template.Render(docContext);
DocViewer.Document = (FlowDocument) XamlReader.Parse(docString);
}
}
}
```
Тут все просто. Открываем поток файла с шаблоном, создаем контекст шаблона и рендерим разметку FlowDocument. С помощью XamlReader'а парсим полученную разметку и помещаем созданный экземпляр в наш FlowDocumentReader. Если нас все устраивает, то переходим к конвертации этого документа в PDF.
#### Генерация PDF
```
private void ButtonBase_OnClick(object sender, RoutedEventArgs e)
{
using (var stream = new FileStream("doc.xps", FileMode.Create))
{
using (var package = Package.Open(stream, FileMode.Create, FileAccess.ReadWrite))
{
using (var xpsDoc = new XpsDocument(package, CompressionOption.Maximum))
{
var rsm = new XpsSerializationManager(new XpsPackagingPolicy(xpsDoc), false);
var paginator = ((IDocumentPaginatorSource)DocViewer.Document).DocumentPaginator;
rsm.SaveAsXaml(paginator);
rsm.Commit();
}
}
stream.Position = 0;
var pdfXpsDoc = PdfSharp.Xps.XpsModel.XpsDocument.Open(stream);
PdfSharp.Xps.XpsConverter.Convert(pdfXpsDoc, "doc.pdf", 0);
}
}
```
И здесь все просто. Генерируется package XPS-документа (как известно, XPS — это zip-архив cо множеством XML и прочих ресурсов). Отрендеренный нами ранее FlowDocument сохраняется в созданный XPS-пакет. (До закрытия!) потока XPS-пакета производится загрузка XPS-документа средствами PDFSharp. После этого загруженный XPS конвертируется в PDF.
#### Заключение
В заключение хочется привести список преимуществ, которые я выделил для себя в таком подходе.
* Бесплатность — нам удалось решить одну из важных бизнесс-задач с помощью бесплатных библиотек (MIT)
* FlowDocument в качестве посредника — это практически нативная поддержка страничной структуры и возможность использования WPF контролов внутри документа
* Стилизация — благодаря использованию FlowDocument имеется возможность стилизации документа WPF стилями
* Интерактивность — т.к. можно использовать WPF контролы, то до «распечатки» в PDF пользователь сможет произвести некие изменения и вычисления в документе, если потребуется. Даже применение Binding возможно в таком случае (правда есть с этим некоторые проблемы — нужен пинок для Dispatcher для запуска обновления Binding).
* Visual Designer — я могу пользоваться привычным дизайнером Visual Studio при подготовке шаблона. Единственное огорчение — биндинги DotLiquid вида "{{ someProp }}" несовместимы с разметкой XAML. Можно обойти вставкой в начале "{}":
СПАСИБО ЗА ВНИМАНИЕ! | https://habr.com/ru/post/201836/ | null | ru | null |
# RxConnect — когда React встречает RxJS
Данный перевод является русскоязычной интерпретацией документации, которую я сам и написал, поэтому не стесняйтесь задавать вопросы.
Введение
========
Обрабатывать пользовательский ввод может быть не так просто, как кажется. Мы же не хотим отправлять запросы на сервер пока пользователь всё ещё набирает свой запрос? И, конечно же, пользователь должен всегда видеть результат на последний запрос, который он отослал.
Существуют разные способы реагирования на интерактивные события в React приложениях, и, по моему мнению, реактивный подход (благодаря таким библиотекам, как RxJS или Bacon) — один из самых лучших. Вот только для того, чтобы использовать RxJS и React одновременно, Вам придётся иметь дело с жизненным циклом React компонента, вручную управлять подписками на потоки и так далее. Хорошая новость — всё это можно делать автоматически с помощью RxConnect — библиотеки, разработанной в процессе миграции с Angular на React в ZeroTurnaround.
Мотивация
=========
Сначала был React. И было Благо.
… Но затем люди поняли, что делать API запросы и раскидывать состояние приложения по разным компонентам — это не хорошо. И появилась Flux архитектура. И стало хорошо.
… Но затем люди поняли, что вместо того, чтобы иметь много хранилищ данных, может быть одно. И появился Redux. И стало хорошо и централизированно.
Вот только появилась другая проблема — стало сложно делать простые вещи, а каждый чих (такой как поле ввода логина) должен проходить через action creator-ы, reducer-ы, и храниться в глобальном состоянии. И тут все вспомнили, что у React компонента… может быть локальное состояние! [Как хорошо подметил Dan](https://github.com/reactjs/redux/issues/1287):
> Используйте состояние React компонента там, где это неважно для глобального состояния приложения и когда оно (локальное состояние) не меняется путём сложных трансформаций. Например, состояние checkbox-а, поле формы.
>
> Используйте Redux как хранилище состояния для глобального состояния либо для состояния, которое изменяется путём сложных трансформаций. Например, кэш пользователей, или черновик статьи, вводимой пользователем.
>
> Другими словами, делайте то, что кажется наименее странным ( неприемлемым ).
И RxJS как никогда лучше подходит для того, чтобы управлять этим локальным состоянием.
Рассмотрим пример:
Мы напишем простейший таймер, отображающий сколько секунд прошло, без RxJS или других библиотек:
```
class Timer extends React.Component {
state = {
counter: 0
}
componentWillMount() {
setInterval(
() => this.setState(state => ({ counter: state.counter + 1 })),
1000
)
}
render() {
return { this.state.counter }
}
}
```
Просто, не правда ли? Вот только незадача — что произойдёт, когда мы удалим этот компонент со сцены? Он продолжит вызывать `setState()` и бросит исключение, потому что нельзя вызывать `setState()` на удалённых компонентах.
Значит, нам надо убедиться, что мы отпишемся от интервала перед тем, как компонент будет удалён:
```
class Timer extends React.Component {
state = {
value: 0
}
intervalRef = undefined;
componentWillMount() {
this.intervalRef = setInterval(
() => this.setState(state => ({ value: state.value + 1 })),
1000
)
}
componentWillUnmount() {
clearInterval(this.intervalRef);
}
render() {
return { this.state.value }
}
}
```
Эта проблема настолько популярна, что существует даже библиотека для этого: <https://github.com/reactjs/react-timer-mixin>
А теперь представьте, что для каждого Promise-а, интервала, и любой другой асинхронщины нам придётся писать свои обработчики подписывания и отписывания, отдельные библиотеки. Хорошо, что есть RxJS — абстракция, позволяющая обрабатывать такие вещи [реактивно](https://ru.wikipedia.org/wiki/Реактивное_программирование).
Тот же самый пример, но используя один только RxJS, будет выглядеть примерно так:
```
class Timer extends React.Component {
state = {
value: 0
}
subscription = undefined;
componentWillMount() {
this.subscription = Rx.Observable.timer(0, 1000).timestamp().subscribe(::this.setState);
}
componentWillUnmount() {
this.subscription.dispose();
}
render() {
return { this.state.value }
}
}
```
Вот только не многовато ли кода для такой простой задачи? И что, если разработчик забудет вызвать dispose на подписке? И, раз у нас уже есть состояние в виде `Rx.Observable.timer`, зачем нам дублировать его в виде локального состояния компонента?
Вот тут-то нам и поможет RxConnect:
```
import { rxConnect } from "rx-connect";
@rxConnect(
Rx.Observable.timer(0, 1000).timestamp()
)
class Timer extends React.PureComponent {
render() {
return { this.props.value }
}
}
```
(С примером можно поиграться на <http://codepen.io/bsideup/pen/wzvGAE> )
RxConnect реализован в виде [Компонента Высшего Порядка](https://medium.com/@franleplant/react-higher-order-components-in-depth-cf9032ee6c3e#.qdip2d6nb) и берёт на себя всю рутину по управлению подпиской, что делает Ваш код безопасней и улучшает читаемость. Так же компонент теперь есть функция от свойств, т.е. "Pure", что значительно упрощает тестирование за счёт отсутсвия внутреннего состояния.
А начиная с React 0.14 мы можем использовать функции как React компоненты без состояния, за счёт чего код можно превратить в одну строчку:
```
const Timer = rxConnect(Rx.Observable.timer(0, 1000).timestamp())(({ value }) => {value})
```
Правда я нахожу вариант с классом гораздо более читаемым.
Жизненный пример
================
Таймеры — это хорошо, но чаще всего нам приходится иметь дело с ~~скучными~~ API и разного рода сервисами, поэтому давайте разберём более реалистичный пример — поиск статей с Wikipedia.
### Компонент
Начнём с самого компонента:
```
class MyView extends React.PureComponent {
render() {
const { articles, search } = this.props;
return (
Wiki search: search(e.target.value) } />
{ articles && (
{ articles.map(({ title, url }) => (
* [{title}]({url})
) ) }
) }
);
}
}
```
Как Вы могли заметить, он ожидает два свойства:
* **articles** — массив статей (обратите внимание, компонент ничего не знает про то, откуда они берутся)
* **search** — функция, которую он будет вызывать когда пользователь вводит что-то в поле ввода.
Компонент "чистый" и не содержит состояния. Запомните его, ведь мы больше не будем модифицировать его код!
**На заметку: RxConnect работает с существующими React компонентами без модификаций**
### Реактивный компонент
Самое время связать наш компонент с внешним миром:
```
import { rxConnect } from "rx-connect";
@rxConnect(Rx.Observable.of({
articles: [
{
title: "Pure (programming Language)",
url: "https://en.wikipedia.org/wiki/Pure_(programming_language)"
},
{
title: "Reactive programming",
url: "https://en.wikipedia.org/wiki/Reactive_programming"
},
]
}))
class MyView extends React.PureComponent {
// ...
}
```
(Поиграться: <http://codepen.io/bsideup/pen/VKwKGv> )
Здесь мы сымитировали данные, подложив статичный массив из двух элементов, и мы видим, что компонент из отображает! Ура!
\*\*На заметку: функция, переданная в метод `rxConnect` должна вернуть `Observable` свойств компонента.
### Реактивный интерактивный компонент
Всё конечно клёво, но… Поиск? Пользователь до сих пор не может взаимодействовать с нашим компонентом. Требования были:
* Он должен искать на Wikipedia когда пользователь вводит запрос
* Он должен игнорировать результат всех предыдущих запросов если пользователь вводит новый запрос
Благодаря RxJS мы можем легко реализовать это:
```
import { rxConnect, ofActions } from "rx-connect";
function searchWikipedia(search) {
return Rx.DOM
.jsonpRequest(`https://en.wikipedia.org/w/api.php?action=opensearch&search=${search}&format=json&callback=JSONPCallback`)
.pluck("response")
// Wikipedia имеет очень странный формат данных o_O
.map(([,titles,,urls]) => titles.map((title, i) => ({ title, url: urls[i] })))
}
@rxConnect(() => {
const actions = {
search$: new Rx.Subject()
}
const articles$ = actions.search$
.pluck(0) // нас интересует первый переданный аргумент
.flatMapLatest(searchWikipedia)
return Rx.Observable.merge(
Rx.Observable::ofActions(actions),
articles$.map(articles => ({ articles }))
)
})
class MyView extends React.PureComponent {
// ...
}
```
(Поиграться: <http://codepen.io/bsideup/pen/rrNrEo> **ВНИМАНИЕ! Не вводите слишком быстро, иначе Вы упрётесь в ограничение API по кол-ву запросов** (см. дальше) )
Отлично, работает! Мы печатаем и мы видим результат.
Пройдёмся по коду шаг-за-шагом:
```
const actions = {
search$: new Rx.Subject()
}
```
Здесь мы создаём объект из действий пользователя. Они являются [Субъектами](https://github.com/Reactive-Extensions/RxJS/blob/master/doc/gettingstarted/subjects.md). Вы можете объявить столько субъектов, сколько Вы хотите.
Видите знак $ в конце имени действия? Это специальная нотация в RxJS чтобы идентифицировать поток данных. RxConnect опустит его, и компонент получит его в виде свойства `search`.
Но действия сами по себе ничего не делают, мы должны реагировать на них с помощью реакций:
```
const articles$ = actions.search$
.pluck(0) // select first passed argument
.flatMapLatest(searchWikipedia)
```
Сейчас у нас есть только одна реакция — на поиск, но их может быть много, вот почему мы объединяем потоки всех реакций в один:
```
return Rx.Observable.merge(
Rx.Observable::ofActions(actions),
articles$.map(articles => ({ articles }))
)
```
Поток статей будет преобразован в свойство `articles` нашего компонента.
### Реактивный интерактивный компонент, учитывающий ограничения API
В текущей реализации мы запрашиваем API каждый раз как пользователь вводит новый символ в поле ввода. Это означает что если пользователь вводит слишком часто, например, 10 символов в секунду, то мы пошлём 10 запросов в секунду. Но пользователь хочет видеть лишь результат для последнего запроса, когда он перестал печатать. И такая ситуация — отличный пример для чего мы выбираем RxJS — потому что он расчитан обрабатывать такие ситуации!
Немного модифицируем нашу реакцию:
```
actions.search$
.debounce(500) // <-- RxJS рулит!
.pluck(0)
.flatMapLatest(searchWikipedia)
```
(Поиграться: <http://codepen.io/bsideup/pen/gwOLdK> (не бойтесь вводить настолько быстро, на сколько можете)
Теперь пользователь может вводить с любой скоростью, ведь мы будем отправлять запрос только когда от пользователя не было ввода в течение 500мс, а значит наш сервер будет получать максимум 2 запроса в секунду.
**На заметку: изучайте RxJS, он шикарен:)**
### Реактивный интерактивный компонент, учитывающий ограничения API, с вниманием к деталям
Напечатайте что-нибудь в поле ввода. После того, как Вы увидели результаты, введите что-нибудь ещё. Старые результаты остаются на экране пока мы не получим ответ от сервера на новый запрос. Это не очень красиво, но мы можем легко это исправить.
Помните я сказал, что мы комбинируем потоки данных, а значит наш компонент реактивен? Благодаря этому, сделать очистку предыдущих результатов не сложней чем отправлять пустой объект одновременно с тем, как мы отправляем запрос на сервер, но до его результата:
```
actions.search$
.debounce(500)
.pluck(0)
.flatMapLatest(search =>
searchWikipedia(search)
.startWith(undefined) // <-- Наш поток начинается с undefined, а потом, когда пришёл ответ, завершается ответом от сервера
)
```
Результат: <http://codepen.io/bsideup/pen/mAbaom>
Redux
=====
В целях сократить размер статьи, я не стану охватывать тему Redux-а, скажу лишь, что RxConnect отлично работает с Redux и позволяет так же реактивно связывать ваши компоненты, заменяя `@connect`. Например:
```
@rxConnect((props$, state$, dispatch) => {
const actions = {
logout: () => dispatch(logout()),
};
const user$ = state$.pluck("user").distinctUntilChanged();
return Rx.Observable.merge(
Rx.Observable::ofActions(actions),
user$.map(user => ({ user })),
);
})
export default class MainView extends React.PureComponent {
// ...
}
```
Пример: <https://github.com/bsideup/rx-connect/tree/master/examples/blog/>
Демо: <https://bsideup.github.io/rx-connect/examples/blog/dist/>
Заключение
==========
Реактивное программирование может быть легче, чем кажется. После того, как мы перевели бОльшую часть наших компонент на RxJS, мы уже не видем другого пути. А RxConnect позволило нам избежать ненужного кода и потенциальных ошибок управления подписками.
Ссылки
======
* <https://bsideup.gitbooks.io/rxconnect/content/> — документация
* <https://github.com/bsideup/rx-connect> — RxConnect на GitHub | https://habr.com/ru/post/309226/ | null | ru | null |
# Foobnix — новый музыкальный плеер
Думаю ни для кого не секрет что в линуксе великое множество разнообразных музыкальных плееров на любой вкус — Rhytmbox, Exaile, Banshee, DeadBeef, Decibel, Clementine, Amarok, XNoise, QMMP, Audacious, Minitunes, gMusicbrowser, MPD(Sonata...) итд. Все они имеют как преимущества так и недостатки, многие поддерживают плагины для расширения функционала, некоторые умеют использовать скины — казалось бы что совсем не проблема найти то что полностью устроит именно тебя. Но пробовав их все лично я так и не смог остановить свой выбор на одном, нужные мне функции были в разных плеерах. Вот так и пользовался я сразу 3 плеерами:* QMMP — для быстрого и удобного проигрывания локальной музыки по каталогам
* Exaile — для проигрывания музыкальной коллекции и музыки с вКонтакта
* prostopleer.com — в основном для прослушивания популярных треков с радиостанций(TOP100 песен из 60 радио) в онлайне, иногда скачивая нужные треки себе.
Естественно было не очень удобно и тут случилось чудо — вчера совершенно случайно наткнулся на пост о плеере Foobnix, сначала подумал что это очередной велосипед и даже не хотел пробовать, но все же прочитал описание на сайте, потом поставил и не пожалел. Очень обрадовало то что разработчик русский и довольно активно дорабатывает плеер. На текущий момент последняя версия плеера всего 0.2.0 — но он уже достаточно много умеет.
[](https://habr.com/images/px.gif#%3D%22http%3A%2F%2Fimg821.imageshack.us%2Fimg821%2F9684%2Fkatyperryhackensacklive.png%22 "Открыть полноразмерный скрин")
*Описание взято с официального сайта плеера, ведь никто не расскажет лучше о своем «детище» чем автор.*
---
Плеер написан на Python, GTK+, Glade
Идя создания плеера была такая, что сейчас практически вся музыка есть в интернете (видеоклипы, вконтакте, ласт.фм и другие сайты), но она или не структурированная или существуют каталоги, но нельзя прослушать или платная.
Так возникла идея написать плеер, который сможет искать различные списки музыки (Например список песен из альбома) и потом к каждой из них искать музыку на разных источниках. Собрать все в одной программе, которая свернется в иконку :)#### **Кратко что сейчас умеет плеер:**
##### **Как плеер локальной музыки**
1.0 Сканировать папку с музыкой.
1.1 Играть локальную музыку любых форматов, что поддерживает gstreamer
1.2 Навигация по файлам в виде дерева (не люблю коллекции)
1.3 Быстрый фильтр по названию артиста-альбома (легко находить исполнителя)
1.4 Каждый новый плейлист отображается в табах, что позволяет отображать историю прослушанной музыки
1.5 Создавать плейлисты
1.6 Сохранять выделенную музыку-плейлисты в новую папку (Например для следующей записи на СД)
1.7 Скроблер музыки на ласт.фм
1.8 Отображение лирики к текущей песни если есть.
1.9 Экспериментальная поддержка CUE файлов
##### **Как плеер интернет музыки**
2.-1 Не обязательно вводить свой логин\пароль ВКонтакте и last.fm
2.0 Поиск самых популярных песен исполнителя по рейтингу ласт.фм
2.1 Поиск самых популярных альбомов и их песен по рейтингу ласт.фм
2.2 Поиск наиболее похожих артистов и их песен по рейтингу ласт.фм
2.3 Поиск наиболее соответствующей музыки по жанру или тегу по рейтингу ласт.фм
2.4 Поиск любой аудио информации по Вконтакте и ее прослушивание.
2.5 Отображение каждого поиска в новой табе, возможность смотреть историю.
2.6 Отображение из какого альбома (года) текущая песня
2.7 Отображение наиболее похожих исполнителей к тому что играет
2.8 Отображение наиболее похожих песен к той что играет
2.9 Слылки на биографию артиста на wikipedia, last.fm, musicbrainz
2.10 Скроблер музыки на ласт.фм
2.11 Установить в конфигурации, все что прослушивается кешируется-сохраняется в указанную папку
2.12 Сохранить выделенное в эту папку сразу без прослушивания
2.13 Сохранить как выделенное в любую папку сразу
2.14 Если в поле поиска вбить ссылку на пользователя или группу вконтакте то есть возможно прослушивать-сохранять музыку из групп вконтакте
2.15 Отображение лирики к текущей песни если есть
2.16 Прослушивание радиостанций
2.17 Скачивать музыку с сайта Вконтакте
##### **Видео описание некоторых возможностей**
---
На данный момент в плеере НЕТ фонотеки(лично мне не нужна например), но планируется. Советую ознакомится с планами развития плеера по ссылкам ниже, также вы можете оставить свои предложения.
[Официальный сайт](http://www.foobnix.com)
[Список реализованного и задуманного функционала](https://docs.google.com/Doc?docid=0AambvFr2K5zjZGd4eDIyNWJfMjJkN2JyYnRkdw&hl=ru)
[Таблица багов и предложений](https://spreadsheets0.google.com/ccc?key=tr-9xbzL9TwsBfX1IvW0Jzw&authkey=CJq8ttII&hl=ru#gid=0)
[Исходники на гуглкоде](http://code.google.com/p/foobnix/)
[Установка Foobnix на Windows для извращенцев](http://code.google.com/p/foobnix/wiki/Install_on_Windows)
[Скачать можно deb-пакеты или исходники](http://code.google.com/p/foobnix/downloads/list) или из SVN
`svn checkout foobnix.googlecode.com/svn/trunk foobnix-read-only`
**UPD. Я НИКАКОГО ОТНОШЕНИЯ К РАЗРАБОТЧИКАМ НЕ ИМЕЮ. ВСЕ ПОЖЕЛАНИЯ И БАГРЕПОРТЫ ОТПРАВЛЯЙТЕ ПО ПРИВЕДЕННЫМ ВЫШЕ ССЫЛКАМ.**
**UPD2.** Не прошло и суток как плеер обновился, качаем с оффсайта. Список изменений:
0.2.1-0a
\*Замечена бага с директориями музыки после обновления до новой версии, нужно удалить старый конфиг rm -rf $USER/foobnix\_conf.pkl
\*Бага с ВКонтакте, не играет музыку… вечером посмотрю (исправлено в 0.2.1-1)
1)Настройки вынесены в отдельное окно
2)Возможность указывать несколько директорий с музыкой
3)Изменен внешний вид
4)Переключатели Музыку-Радио-Плейлисты вдавливаются.
5)Заложена основа для различных настроек
 | https://habr.com/ru/post/102450/ | null | ru | null |
# Новшества JavaScript: итоги Google I/O 2019. Часть 1
Материал, первую часть перевода которого мы сегодня публикуем, посвящён новым стандартным возможностям JavaScript, о которых шла речь на конференции [Google I/O 2019](https://www.youtube.com/watch?v=c0oy0vQKEZE). В частности, здесь мы поговорим о регулярных выражениях, о полях классов, о работе со строками.
[](https://habr.com/ru/company/ruvds/blog/464129/)
Ретроспективные проверки в регулярных выражениях
------------------------------------------------
Регулярные выражения (Regular Expression, сокращённо — RegEx или RegExp) — это мощная технология обработки строк, которая реализована во множестве языков программирования. Регулярные выражения оказываются очень кстати в тех случаях, когда нужно, например, выполнять поиск фрагментов строк по сложным шаблонам. До недавнего времени в JavaScript-реализации регулярных выражений имелось всё кроме ретроспективных проверок (lookbehind).
Для того чтобы разобраться с тем, что такое ретроспективная проверка, поговорим сначала об опережающих проверках (lookahead), которые уже поддерживаются в JavaScript.
→ [Вторая часть](https://habr.com/ru/company/ruvds/blog/464131/)
### ▍Опережающая проверка
Синтаксис опережающих проверок в регулярных выражениях позволяет выполнять поиск фрагментов строк, когда известно, что правее их находятся другие фрагменты. Например, при работе со строкой `MangoJuice, VanillaShake, GrapeJuice` можно воспользоваться синтаксисом положительной опережающей проверки для нахождения слов, сразу после которых идёт слово `Juice`. В нашем случае это — слова `Mango` и `Grape`.
Существует два вида опережающих проверок. Это — положительные опережающие проверки (positive lookahead) и отрицательные опережающие проверки (negative lookahead).
#### Положительная опережающая проверка
Положительная опережающая проверка используется для поиска строк, правее которых находятся другие, заранее известные строки. Вот как выглядит синтаксис регулярного выражения, используемого для такой проверки:
```
/[a-zA-Z]+(?=Juice)/
```
Этот шаблон позволяет выбирать слова, состоящие из строчных или прописных букв, после которых есть слово `Juice`. Не стоит путать структуры, описывающие опережающие и ретроспективные проверки, с группами (capture group). Хотя условия этих проверок и записываются в круглых скобках, система не выполняет их захвата. Давайте рассмотрим пример положительной опережающей проверки.
```
const testString = "MangoJuice, VanillaShake, GrapeJuice";
const testRegExp = /[a-zA-Z]+(?=Juice)/g;
const matches = testString.match( testRegExp );
console.log( matches ); // ["Mango", "Grape"]
```
#### Отрицательная опережающая проверка
Если рассмотреть, используя вышеприведённую строку, механизм действия отрицательных опережающих проверок, то окажется, что они позволяют находить слова, правее которых нет слова `Juice`. Синтаксис отрицательных опережающих проверок похож на синтаксис положительных проверок. Однако в нём имеется одна особенность, которая заключается в том, что символ `=` (равно) меняется на символ `!` (восклицательный знак). Вот как это выглядит:
```
/[a-zA-Z]+(?!Juice)/
```
Это регулярное выражение позволит выбрать все слова, правее которых нет слова `Juice`. Но при применении такого шаблона выбранными окажутся все слова в строке (`MangoJuice, VanillaShake, GrapeJuice`). Дело в том, что, по мнению системы, ни одно слово здесь не завершается `Juice`. В результате для того, чтобы достичь желаемого результата, нужно уточнить регулярное выражение и переписать его так:
```
/(Mango|Vanilla|Grape)(?!Juice)/
```
Использование этого шаблона позволит выбрать слова `Mango`, или `Vanilla`, или `Grape`, после которых нет слова `Juice`. Вот пример:
```
const testString = "MangoJuice, VanillaShake, GrapeJuice";
const testRegExp = /(Mango|Vanilla|Grape)(?!Juice)/g;
const matches = testString.match( testRegExp );
console.log( matches ); // ["Vanilla"]
```
### ▍Ретроспективная проверка
По аналогии с синтаксисом опережающих проверок, синтаксис ретроспективных проверок позволяет выбирать последовательности символов только в том случае, если левее этих последовательностей находится некий заданный шаблон. Например, при обработке строки `FrozenBananas, DriedApples, FrozenFish` мы можем воспользоваться положительной ретроспективной проверкой для того, чтобы найти слова, левее которых есть слово `Frozen`. В нашем случае этому условию соответствуют слова `Bananas` и `Fish`.
Существуют, как и в случае с опережающими проверками, положительные ретроспективные проверки (positive lookbehind) и отрицательные ретроспективные проверки (negative или negating lookbehind).
#### Положительная ретроспективная проверка
Положительные ретроспективные проверки используются для поиска шаблонов, левее которых находятся другие шаблоны. Вот пример синтаксической конструкции, используемой для описания подобных проверок:
```
/(?<=Frozen)[a-zA-Z]+/
```
Здесь используется символ `<`, которого не было при описании опережающих проверок. Кроме того, условие в регулярном выражении расположено не справа от интересующего нас шаблона, а слева. Используя вышеописанный шаблон можно выбрать все слова, начинающиеся с `Frozen`. Рассмотрим пример:
```
const testString = "FrozenBananas, DriedApples, FrozenFish";
const testRegExp = /(?<=Frozen)[a-zA-Z]+/g;
const matches = testString.match( testRegExp );
console.log( matches ); // ["Bananas", "Fish"]
```
#### Отрицательная ретроспективная проверка
Механизм отрицательных ретроспективных проверок позволяет искать в строках шаблоны, левее которых нет заданного шаблона. Например, если нужно выбрать в строке `FrozenBananas, DriedApples, FrozenFish` слова, которые не начинаются с `Frozen`, можно попытаться использовать такое регулярное выражение:
```
/(?
```
Но, так как использование этой конструкции приведёт к выбору всех слов из строки, так как ни одно из них не начинается с `Frozen`, регулярное выражение нужно уточнить:
```
/(?
```
Вот пример:
```
const testString = "FrozenBananas, DriedApples, FrozenFish";
const testRegExp = /(?
```
### → Поддержка
В этом и в других подобных разделах будут приводиться сведения об этапе согласования описываемых возможностей JS в техническом комитете 39 (Technical Committee 39, TC39), который отвечает в ECMA International за поддержку спецификаций ECMAScript. В таких разделах будут приведены и данные о версиях Chrome и Node.js (а иногда и о версии Firefox), начиная с которых можно пользоваться соответствующими возможностями.
* TC39: [Stage 4](https://github.com/tc39/proposal-regexp-lookbehind)
* Chrome: [62+](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp)
* Node: 8.10.0+
Поля классов
------------
Поле класса — это новая синтаксическая конструкция, используемая для определения свойств экземпляров класса (объектов) за пределами конструктора класса. Существуют два типа полей классов: публичные поля (public class fields) и приватные поля (private class fields).
### ▍Публичные поля классов
До недавнего времени свойства объектов нужно было определять внутри конструктора класса. Эти свойства были публичными (общедоступными). Это означает, что к ним можно было обращаться, работая с экземпляром класса (объектом). Вот пример объявления общедоступного свойства:
```
class Dog {
constructor() {
this.name = 'Tommy';
}
}
```
Когда нужно было создать класс, который расширял бы некий родительский класс, необходимо было вызывать `super()` в конструкторе дочернего класса. Делать это нужно было до того, как к дочернему классу можно было бы добавлять его собственные свойства. Вот как это выглядит:
```
class Animal {}
class Dog extends Animal {
constructor() {
super(); // вызываем super перед использованием `this` в конструкторе
this.sound = 'Woof! Woof!';
}
makeSound() {
console.log( this.sound );
}
}
// создаём экземпляр класса
const tommy = new Dog();
tommy.makeSound(); // Woof! Woof!
```
Благодаря появлению синтаксиса публичных полей класса можно описывать поля класса за пределами конструктора. Система при этом выполнит неявный вызов `super()`.
```
class Animal {}
class Dog extends Animal {
sound = 'Woof! Woof!'; // публичное поле класса
makeSound() {
console.log( this.sound );
}
}
// создаём экземпляр класса
const tommy = new Dog();
tommy.makeSound(); // Woof! Woof!
```
При неявном вызове `super()` ему передаются все аргументы, предоставленные пользователем при создании экземпляра класса (это — стандартное поведение JavaScript, тут нет ничего особенного, связанного с приватными полями классов). Если конструктор родительского класса нуждается в аргументах, подготовленных особенным образом, нужно вызвать `super()` самостоятельно. Взглянем на результаты работы неявного вызова конструктора родительского класса при создании экземпляра дочернего класса.
```
class Animal {
constructor( ...args ) {
console.log( 'Animal args:', args );
}
}
class Dog extends Animal {
sound = 'Woof! Woof!'; // публичное поле класса
makeSound() {
console.log( this.sound );
}
}
// создаём экземпляр класса
const tommy = new Dog( 'Tommy', 'Loves', 'Toys!' );
tommy.makeSound(); // Animal args: [ 'Tommy', 'Loves', 'Toys!' ]
```
### ▍Приватные поля классов
Как известно, в JavaScript нет модификаторов доступа к полям классов наподобие `public`, `private` или `protected`. Все свойства объектов по умолчанию являются публичными. Это означает, что доступ к ним ничем не ограничен. Ближе всего к тому, чтобы сделать некое свойство объекта подобным приватному свойству, можно подойти, используя тип данных `Symbol`. Это позволяет скрывать свойства объектов от внешнего мира. Возможно, вы пользовались именами свойств с префиксом `_` (знак подчёркивания) для того чтобы указать на то, что соответствующие свойства нужно считать предназначенными лишь использования внутри объекта. Однако это — лишь нечто вроде уведомления для тех, кто будет пользоваться объектом. Это не решает проблему реального ограничения доступа к свойствам.
Благодаря механизму приватных полей классов можно сделать так, что свойства класса будут доступны лишь внутри этого класса. Это приводит к тому, что к ним нельзя обратиться извне и работая с экземпляром класса (объектом). Возьмём предыдущий пример и попробуем обратиться извне к свойству класса, при объявлении которого использовался префикс `_`.
```
class Dog {
_sound = 'Woof! Woof!'; // это свойство должно считаться приватным
makeSound() {
console.log( this._sound );
}
}
// создаём экземпляр класса
const tommy = new Dog();
console.log( tommy._sound ); // Woof! Woof!
```
Как видите, использование префикса `_` не позволяет решить нашу проблему. Приватные поля классов можно объявлять так же, как и публичные, но вместо префикса в виде символа подчёркивания, к их именам надо добавлять префикс в виде символа решётки (`#`). Попытка несанкционированного доступа к объявленному подобным образом приватному свойству объекта приведёт к следующей ошибке:
```
SyntaxError: Undefined private field
```
Вот пример:
```
class Dog {
#sound = 'Woof! Woof!'; // это - приватное свойство
makeSound() {
console.log( this.#sound );
}
}
// создаём экземпляр класса
const tommy = new Dog();
tommy.makeSound() // Woof! Woof!
//console.log( tommy.#sound ); // SyntaxError
```
Обратите внимание на то, что доступ к приватным свойствам можно получить только из класса, в котором они объявлены. В результате подобными свойствами родительского класса не могут напрямую пользоваться классы-потомки.
Объявлять приватные (и публичные) поля можно и не записывая в них некие значения:
```
class Dog {
#name;
constructor( name ) {
this.#name = name;
}
showName() {
console.log( this.#name );
}
}
// создаём экземпляр класса
const tommy = new Dog( 'Tommy' );
tommy.showName(); // Tommy
```
### → Поддержка
* TC39: [Stage 3](https://github.com/tc39/proposal-class-fields)
* Chrome: 74+
* Node: 12+
Метод строк .matchAll()
-----------------------
В прототипе типа данных `String` имеется метод `.match()`, который возвращает массив фрагментов строки, соответствующих условию, заданному регулярным выражением. Вот пример использования этого метода:
```
const colors = "#EEE, #CCC, #FAFAFA, #F00, #000";
const matchColorRegExp = /([A-Z0-9]+)/g;
console.log( colors.match( matchColorRegExp ) );
// Вывод:
["EEE", "CCC", "FAFAFA", "F00", "000"]
```
При использовании этого метода, однако, не даётся дополнительных сведений (вроде индексов) о найденных фрагментах строки. Если убрать флаг `g` из регулярного выражения, передаваемого методу `.match()` — он вернёт массив, в котором будут содержаться дополнительные сведения о результатах поиска. Правда, при таком подходе найден будет лишь первый фрагмент строки, соответствующий регулярному выражению.
```
const colors = "#EEE, #CCC, #FAFAFA, #F00, #000";
const matchColorRegExp = /#([A-Z0-9]+)/;
console.log( colors.match( matchColorRegExp ) );
// Вывод: (для удобства просмотра тут представлен сокращённый вариант вывода)
["#EEE", "EEE", index: 0, input: ""]
```
Для того чтобы получить нечто подобное, но уже для нескольких фрагментов строки, придётся пользоваться методом регулярных выражений `.exec()`. Конструкции, которые для этого нужны, сложнее, чем та, в которой для получения подобных результатов использовался бы вызов единственного метода строки. В частности, здесь нам понадобится цикл `while`, который будет выполняться до тех пор, пока `.exec()` не вернёт `null`. Пользуясь этим подходом, учитывайте то, что `.exec()` не возвращает итератор.
```
const colors = "#EEE, #CCC, #FAFAFA, #F00, #000";
const matchColorRegExp = /#([A-Z0-9]+)/g;
// в строгом режиме будет выдано сообщение об ошибке,
// Uncaught ReferenceError: match is not defined
while( match = matchColorRegExp.exec( colors ) ) {
console.log( match );
}
// Вывод: (для удобства просмотра тут представлен сокращённый вариант вывода)
["#EEE", "EEE", index: 0, input: ""]
["#CCC", "CCC", index: 6, input: ""]
["#FAFAFA", "FAFAFA", index: 12, input: ""]
["#F00", "F00", index: 21, input: input: ""]
["#000", "000", index: 27, input: input: ""]
```
Для того чтобы решать подобные задачи, теперь мы можем пользоваться методом строк `.matchAll()`, который возвращает итератор. Каждый вызов метода `.next()` этого итератора приводит к возврату очередного элемента из результатов поиска. В результате вышеприведённый пример можно переписать так:
```
const colors = "#EEE, #CCC, #FAFAFA, #F00, #000";
const matchColorRegExp = /#([A-Z0-9]+)/g;
console.log( ...colors.matchAll( matchColorRegExp ) );
// Вывод: (для удобства просмотра тут представлен сокращённый вариант вывода)
["#EEE", "EEE", index: 0, input: ""]
["#CCC", "CCC", index: 6, input: ""]
["#FAFAFA", "FAFAFA", index: 12, input: ""]
["#F00", "F00", index: 21, input: input: ""]
["#000", "000", index: 27, input: input: ""]
```
### → Поддержка
* TC39: [stage 4](https://github.com/tc39/proposal-string-matchall/issues/21)
* Chrome: [73+](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/matchAll)
* Node: 12+
* Firefox: 67+
Именованные группы в регулярных выражениях
------------------------------------------
Концепция групп в JavaScript-реализации механизмов регулярных выражений немного отличается от реализации аналогичной концепции в других языках. А именно, когда, пользуясь JavaScript, RegEx-шаблон помещают в круглые скобки (за исключением тех случаев, когда круглые скобки используются для оформления ретроспективных или опережающих проверок), шаблон превращается в группу.
Захваченные группой фрагменты строки найдут отражение в результатах применения регулярного выражения.
В предыдущем примере можно было видеть то, что первый элемент массива с результатами поиска представляет собой то, что соответствует всему регулярному выражению, а второй — то, что соответствует группе. Вот этот элемент массива:
```
["#EEE", "EEE", index: 0, input: ""]
```
Если в регулярном выражении имеется несколько групп, то они попадут в результаты обработки строки в порядке их описания в регулярном выражении. Рассмотрим пример:
```
const str = "My name is John Doe.";
const matchRegExp = /My name is ([a-z]+) ([a-z]+)/i;
const result = str.match( matchRegExp );console.log( result );
// если константа result равна null - возникнет ошибка
console.log( { firstName: result[1], lastName: result[2] } );
// Вывод:
["My name is John Doe", "John", "Doe", index: 0, input: "My name is John Doe.", groups: undefined]
{firstName: "John", lastName: "Doe"}
```
Тут видно, что первым элементом выходных данных является вся строка, соответствующая регулярному выражению. Второй и третий элементы представляют собой то, что было захвачено группами.
Использование именованных групп позволяет сохранять то, что захватывают группы, внутри объекта `groups`, имена свойств которого соответствуют именам, назначенным группам.
```
const str = "My name is John Doe.";
const matchRegExp = /My name is (?[a-z]+) (?[a-z]+)/i;
const result = str.match( matchRegExp );
console.log( result );
console.log( result.groups );
// Вывод:
["My name is John Doe", "John", "Doe", index: 0, input: "My name is John Doe.", groups: {firstName: "John", lastName: "Doe"}]
{firstName: "John", lastName: "Doe"}
```
Надо отметить, что именованные группы нормально работают и вместе с методом `.matchAll()`.
### → Поддержка
* TC39: [Stage 4](https://github.com/tc39/proposal-regexp-named-groups)
* Chrome: 64+
* Node: 10+
Продолжение следует…
**Уважаемые читатели!** Пользовались ли вы уже какими-нибудь из описанных здесь новшеств JavaScript?
[](https://ruvds.com/vps_start/) | https://habr.com/ru/post/464129/ | null | ru | null |
# PHPUnit: простой синтаксис для создания mock-объектов
1. почему не mockery
2. основное преимущество — синтаксис
3. моки — нативные
4. создание stub-объектов
5. мокирование свойств класса
6. mock injection
7. удобные методы для работы с Reflection
8. как добавить в проект
Почему не Mockery
-----------------
PHPUnit — стандартный, наиболее распространенный фреймворк для написания unit-тестов в мире PHP. Ничего удивительного — он хорошо справляется с возложенными на него обязанностями. Но если говорить о стандартном синтаксисе создания mock-объектов, многие люди жалуются на его некоторую громоздкость. Они предлагают различные плагины для создания моков, такие как Mockery (я понимаю, что это не просто плагин).
Однако, я уверен что PHPUnit обладает достаточно хорошо развитой системой для создания моков, чтобы продолжать его использовать. PHPUnit активно развивается: не так давно были добавлены мокирование трейтов, мокирование несуществующих классов — для TDD.
И этот проект XPMock — это способ упростить синтаксис создания моков. Нужно подчеркнуть, что XPMock не создает собственные моки, и не делает никаких оберток над моками PHPUnit. XPMock вызывает те же самые методы PHPUnit, создавая тем самым те же самые моки, только несколько проще.
Основное преимущество — синтаксис
---------------------------------
Стандартный синтаксис для создания мока (объекта-заглушки с тремя методами) в PHPUnit выглядит так:
```
$mock = $this->getMockBuilder('MyClass')
->setMethods(['getBool', 'getNumber', 'getString'])
->disableOriginalConstructor()
->getMock();
$mock->expects($this->any())
->method('getBool')
->will($this->returnValue(true));
$mock->expects($this->any())
->method('getNumber')
->will($this->returnValue(1));
$mock->expects($this->any())
->method('getString')
->will($this->returnValue('string'));
```
Те, кто мокируют большую часть зависимостей в unit-тестах, замечают, что код теста очень быстро разрастается именно из-за таких конструкций.
Если же использовать XPMock, то создание мока становится значительно короче:
```
$this->mock('MyClass')
->getBool(true)
->getNumber(1)
->getString('string')
->new();
```
Моки — нативные
---------------
XPMock
— не создает свои собственные моки
— не делает дополнительных оберток над моками PHPUnit
— поддерживает все нативные конструкции PHPUnit
Например,
```
$mock->getNumber($this->once())
```
это то же самое, что написать
```
$mock->expects($this->once())
->method('getNumber')
->will($this->returnValue(null))
```
Другие примеры короткой записи часто используемых конструкций можно посмотреть здесь: [github.com/ptrofimov/xpmock](https://github.com/ptrofimov/xpmock)
Создание stub-объектов
----------------------
Stub-объекты, или объекты-заглушки, — это мок-объекты, у которых все методы по умолчанию перекрывают реальные методы и возвращают null. В PHPUnit в синтаксисе нет деления на моки, стабы и иже с ними. Все искусственные объекты для тестирования создаются с помощью getMock или getMockBuilder.
В XPMock включен специальный метод stub который вернет мок, у которого все методы по умолчанию возвращают null. Это и улучшает читаемость кода, и избавляет от необходимости вызывать метод setMethods при создании реальных моков.
Мокирование свойств класса
--------------------------
PHPUnit не умеет мокировать свойства класса. XPMock — тоже. Однако он предоставляет удобные методы задания свойств у создаваемого мока через Reflection. Указанные при создании мока присваивания будут выполнены сразу после вызова метода-конструктора new.
```
$this->mock(‘MyClass’)
->__set(‘property’, $value)
->new();
```
Можно использовать и привычный синтаксис задания свойств без использования магических методов.
Mock injection
--------------
Очень часто при создании моков их нужно сразу же внедрить в другие объекты. Например, создать instance синглтона и внедрить ссылку на него в статическую переменную instance того же класса. Обычно это делается через Reflection. XPMock и здесь предоставляет удобный синтаксис для таких действий.
```
$this->mock(‘MyClass’)
->injectTo($object, ‘property’)
->new();
```
Удобные методы для работы с Reflection
--------------------------------------
XPMock предоставляет и общий короткий синтаксис для работы с объектами через Reflection.
Например, чтобы получить закрытое свойство объекта, обычно нужно писать так:
```
$property = new \ReflectionProperty(‘MyClass’, ‘property’);
$property->setAccessible(true);
$value = $property->getValue($object);
```
С XPMock можно это делать так:
```
$value = $this->reflect('MyClass')->property;
```
Подобным синтаксисом можно получать значения закрытых/открытых статических/нестатических свойств объектов, а также вызывать закрытые методы.
Как добавить в проект
---------------------
XPMock легко встраивается в существующие тесты и не мешает работать нативному синтаксису создания моков PHPUnit.
Вариант 1. Добавить трейт XPMock к существующему тесту (подходит для PHP>=5.4)
```
class MyTestCase extends \PHPUnit_Framework_TestCase
{
use \Xpmock\TestCaseTrait;
}
```
Вариант 2. Унаследовать класс теста от соответстующего класса XPMock (подходит для PHP>=5.3)
```
class MyTestCase extends \Xpmock\TestCase
{
}
```
Добавить XPMock в проект очень просто — через менеджер зависимостей composer. Инструкция по установке из 2-х шагов здесь — [github.com/ptrofimov/xpmock#installation](https://github.com/ptrofimov/xpmock#installation) | https://habr.com/ru/post/183010/ | null | ru | null |
# Задача на сортировку
Возможно, кому-то эта задача покажется пустяковой, но лично я потратил на неё несколько часов, израсходовав подсказки «мнение зала» и «звонок другу». Зачем я это решал? Ответ прост: мне действительно нужно было реализовать такой подход для моего небольшого сайтика [Одио.ру](http://www.odio.ru/). Если вкратце, то там публикуются записи с самых разных сайтов, стягиваемые по RSS. Сложность в том, что даты в этих записях могут полностью совпадать (даже в рамках одной ленты), при этом последовательность ID имеет смысл только в рамках одной ленты, но никак не влияет на весь поток записей. Итак, давайте перейдем к условиям задачи.
Поскольку это блог о MySQL, то приведу сразу `SHOW CREATE TABLE` для тестовой таблицы нашей задачи:
`CREATE TABLE `test` (
`id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`date` datetime NOT NULL,
`content` varchar(255) NOT NULL,
PRIMARY KEY (`id`),
KEY `date` (`date`)
) ENGINE=MyISAM;`
Теперь заполняем её тестовыми данными:
`INSERT INTO `test` (`id` ,`date` ,`content`)
VALUES (NULL , '2010-03-01 11:00:00', 'Test 1'),
(NULL , '2010-03-01 12:00:00', 'Test 2'),
(NULL , '2010-03-01 13:00:00', 'Test 4'),
(NULL , '2010-03-01 12:00:00', 'Test 3'),
(NULL , '2010-03-01 14:00:00', 'Test 5');`
В итоге получаем следующую таблицу (`SELECT * FROM `test` ORDER BY `id``):
`| 1 | 2010-03-01 11:00:00 | Test 1 |
| 2 | 2010-03-01 12:00:00 | Test 2 |
| 3 | 2010-03-01 13:00:00 | Test 4 |
| 4 | 2010-03-01 12:00:00 | Test 3 |
| 5 | 2010-03-01 14:00:00 | Test 5 |`
Как видно, сейчас таблица отсортирована по ID и даты идут в неправильном порядке.
Теперь, собственно, сама задача: на входе имеем одну из записей (то есть, нам известны ID и DATE), **нужно получить ID соседних записей** (предыдущей и следующей), при этом, если DATE совпадает, тогда у предыдущей записи будет ID меньше текущей, а у следующей — больше.
Наблюдательный читатель сразу поймет, что если сделать просто (для предыдущей записи): `SELECT `id` FROM `test` WHERE `date` <= $date AND `id` != $id ORDER BY `date` DESC, `id` DESC LIMIT 1`, тогда мы «зациклимся» между записями 2 и 4, потому что у них одинаковые DATE — то есть, 2 будет предыдущей для 4, а 4 будет предыдущей для 2. При этом важно, чтобы у крайних записей (1 и 5) в качестве соседних (соответственно, предыдущей для 1 и следующей для 5) ничего не возвращалось.
Чтобы упростить, давайте будем искать только предыдущую запись. Начинаем с 5 записи, имеем ID=5 и DATE='2010-03-01 14:00:00'. Нужно получить запись 3, и далее получаем уже для условий ID=3 и DATE='2010-03-01 13:00:00', и так далее…
Уточню сразу, задача имеет как минимум одно решение ;) Один запрос — одна предыдущая запись, тот же запрос с другими параметрами — следующая предыдущая запись. То есть, вариант «получить всё и ходить по этому» не подходит. Также не подходит вариант «добавить колонку ORDER\_NUM и перестраивать его для всей таблицы при добавлении новой записи». Ещё больше не подходит вариант «записывать ID уже показанных записей и исключать их из выборки».
В общем, нужен «честный» запрос, который по ID и DATE текущей записи вернёт настоящий ID настоящей предыдущей записи.
Дабы избежать лишнего флейма в комментариях, отвечаю сразу: да, я сознательно повесил ссылку на адрес своего сайта, потому что он является живым примером применения решения данной задачи. Ну и, естественно, как и любому другому сайту, ему хочется, чтобы на него почаще заходили ;)
Также, я оставляю за собой право использовать ваш запрос, если он окажется лучше того, что придумал я ;) Естественно, с вашего разрешения…
Если в условиях задачи что-то непонятно, я с удовольствием уточню в комментариях.
И, пожалуйста, не нужно писать: «Что за бред? Используйте %framework\_name%, он всё сделает за вас...» — мне это не интересно, да и блог о MySQL, задача на сортировку в MySQL, так что всё делаем в рамках MySQL.
**UPDATE** Найдено 1 решение:
`SELECT `id`
FROM `test`
WHERE `date` < $date or (`date` = $date and `id` < $id)
ORDER BY `date` DESC, `id` DESC LIMIT 1`
Прислал: [SabMakc](https://habrahabr.ru/users/sabmakc/)
Есть и другие решения, пожалуй сложнее представленного, но, тем не менее, вы можете продолжить поиски…
**UPDATE 2** Привожу «сложное» трёхэтажное решение этой задачи:
`SELECT `id`, `date`, IF (`date` = $date AND id < $id, 0, 1) AS `ordr`
FROM `test`
WHERE `date` <= $date AND `id` != $id
HAVING `date` < IF (`ordr` = 1, $date, NOW())
ORDER BY `ordr`, `date` DESC, `id` DESC
LIMIT 1`
Это моё решение. По сути, оно делает то же самое, что и предыдущее решение [SabMakc](https://habrahabr.ru/users/sabmakc/), но немного через другие ворота… | https://habr.com/ru/post/85945/ | null | ru | null |
# Борьба с TOAST или будущее JSONB в PostgreSQL
В PostgreSQL есть два типа данных: JSON и JSONB. Первый формат является текстовым хранилищем, в котором json хранится "as is", второй — бинарным, в нем ключи отсортированы (сначала по длине ключа, а потом по его названию), дубликаты удалены, а пробелы удалены. Этот SQL-запрос иллюстрирует различие между JSON и JSONB:
Тип JSONB имеет богатую поддержку, облегчающую работу разработчиков приложений, для него есть встроенные индексы, кроме того, существует расширение Jsquery, в котором реализован язык запросов к JSONB и дополнительные индексы. Когда у меня спрашивают, чем пользоваться, я всегда советую JSONB, так как он позволяет работать очень эффективно.
Однако у постгреса есть серьёзная проблема, которая сказывается и на производительности JSONB — это TOAST, и о ней я говорил в [первой части](https://habr.com/ru/company/oleg-bunin/blog/597187/). Сегодня я расскажу о том, как мы улучшили JSONB для того, чтобы существенно повысить его производительность.
Пример 1. Популярная ошибка
---------------------------
Ее делают, когда торопятся и создают таблицу из JSON, но ID используют внутри. Мы сравнили производительность двух схем, с ID снаружи и внутри JSON:
Popular mistake: CREATE TABLE qq (jsonb)На изображении мы видим, что график красного цвета (то есть время доступа) постоянен и близок к нулю. А время доступа к ID, который лежит в JSON (график желтого цвета) — зависит от размера JSON. Причем зависит линейно — чем длиннее JSON, тем медленнее чтение, более того, эта кривая резко уходит вверх при больших размерах JSONB.
> ***При создании таблицы хорошая практика использовать уникальный ключ (ID) вне JSON для избежания оверхедов JSON, так где это не требуется, например, при операциях связывания таблиц по уникальному ключу.***
>
>
Пример 2. IMDB-тест
-------------------
Мы взяли Internet Movie Database, доступную базу данных о кинематографе и выбрали оттуда 4 ключа. Короткие: id (название фильма, самый популярный ключ), imdb\_id (внутренний id базы данных) и height (рост актера в см). Из длинных взяли тоже довольно популярный ключ roles (список ролей, размером до мегабайта). Запись выглядит примерно так:
Typical IMDB «name» document
```
{
"id": "Connors, Steve (V)",
"roles": [
{
"role": "actor",
"title": "Copperhead Creek (????)"
},
{
"role": "actor",
"title": "Ride the Wanted Trail (????)"
}
],
“height”: “171 cm”,
"imdb_id": 1234567
}
```
После чего мы измерили время доступа к ключу для каждой строчки, повторив запрос 1000 раз, чтобы надежно измерить производительность:
На графике слева (время доступа vs “raw” размера JSON) можно наблюдать 3 участка: inline (размер JSON < 2 Kb), compressed inline (размер сжатого JSON < 2Kb) и то, что TOAST’ится, то есть, размер JSON даже после сжатия > 2 Kb. Сначала мы видим плоский график — там не нужно ни сжатие, ни TOAST, далее идет рост из-за необходимости декомпрессии сжатого JSON, а когда мы начинаем доставать чанки из TOAST, склеивать их и разжимать, то получаем дальнейший рост. На графике справа показана зависимость размер JSON на диске от “сырого” размера - все что, выше 2 Kb (синий цвет) - это зона TOAST, ниже находятся две зоны - то, что помещается в 2Kb несжатым (“raw”) и после сжатия (зеленый цвет).
Отсюда мы поняли:
1. Нужна частичная декомпрессия, то есть разжимать следует только тот чанк, который нам необходим.
2. Мы читаем слишком много чанков, вместо содержащих то, что нам требуется.
Это мы и сделали в JSONB, с помощью множества проведенных экспериментов, реализовав проект по улучшению хранилища TOAST. Покажу, что у нас получилось на примере IMDB.
JSONB deTOAST: Улучшения
------------------------
### Частичная декомпрессия Jsonb
JSONB устроен так, что вначале лежат ключи, а потом идут значения. На рисунке слева показан поиск ключей K1 и K5 в JSON, который состоит из пяти ключей (значение третьего ключа является самым большим), для варианта полной декомпрессии (как это работает в современном потсгресе). В обоих случаях приходится читать весь JSON, в то время как на правой картинке показан случай частичной декомпрессии, когда для того, чтобы получить значение ключа K1, требуется читать только необходимую часть JSON, хотя для ключа K5 (последний ключ) эта оптимизация не работает.
Теперь посмотрим, что изменилось на графике IMDB (слева — то, что было, а справа — изменения):
Jsonb partial decompression results (IMDB)Видно, что упали (ускорились) ключ id (синий) и рост актера (желтый), так как они короткие. А внутреннее id (красное) и роли (зеленое, самый большой кусок) остались вверху, потому что длинный ключ roles блокирует ключ imdb\_id.
### Сортировка ключей по длине
В существующем JSONB ключи отсортированы по их названию, а не по значению, в то время как типичный паттерн использования JSON — это работа с метаданными, которые обычно имеют короткое значение, поэтому, может случиться, что одно большое значение будет мешать доступу к метаданным в конце, как в нашем примере, большое значение V3 будет мешать доступу к V4 и V5.
В JSONB мы отсортировали ключи по их длине. И сделали так, что JSONB сам меняет за вас хранение внутри: сначала лежат короткие метаданные, наиболее используемые ключи. В результате значения лежат не как V1,V2,V3,V4,V5, а как V1, V4, V5, V2, V3, поэтому для доступа к ключу K5 читать придется меньше!
Sorting jsonb keys by lengthНа примере IMDB ниже мы видим, что теперь красный ключ imdb\_id «упал», потому что встал впереди roles (зеленого цвета). Это связано с тем, что roles большие и оказались сзади после сортировки:
Sorting jsonb keys by length results (IMDB)По цифрам же мы получили ускорение в несколько порядков для длинных JSONB.
### Частичный deTOASTing
Дальше мы сделали частичный deTOAST, чтобы читать только нужные чанки. Это привело к тому, что время доступа к ключам перестало зависеть от размера JSON:
Partial deTOASTing results (IMDB)Если на графике слева видно, что была некоторая зависимость от размера JSON для коротких ключей, то на графике справа ее фактически нет, потому что мы берем только тот чанк, который нам нужен.
### Inline TOAST
При TOAST tuple (строка) сжимается до tuple pointer, то есть вместо самого значения там лежит pointer на чанки. Остальное место в tuple, которое есть в странице вашей таблице, не используется. Мы решили часть первого чанка положить обратно в таблицу — насколько хватит места. Теперь есть большая вероятность, что после сортировки по длине ключа именно короткие ключи окажутся в inline, и доступ к ним вообще не будет затрагивать TOAST-хранилище.
Мы добавили к TOAST pointer место для хранение, которое называется Inline chunk. На самом деле это начальный кусок первого чанка. Мы вернули его в таблицу, надеясь, что все короткие ключи (метаданные) попадут туда:
И действительно произошли и другие улучшения. Красная и жёлтая части ушли вниз, и мы ускорились с 1 микросекунды до 100 микросекунд — те же 2 порядка, но поведение стало другое:
Inline TOAST results (IMDB)Но также мы видим, что на графике видна ступенька на месте начала сжатия . Ее мы будем убирать с помощью расшаренных чанков (Shared TOAST).
### Shared TOAST или частичное обновление JSONB
Самое вкусное — это шаринг чанков. Как я рассказывал про TOAST в [первой части](https://habr.com/ru/company/oleg-bunin/blog/597187/), если вы заапдейтили какой-то ключ, у вас перепишется всё — вся строка и все чанки продублируются, появится новая версия. Увеличится не только размер таблицы. Все это еще запишется в WAL (Write-Ahead Log). Если у вас был JSON 10 Мб, и вы поменяли один байт, то занимаемое двумя версиями строки место увеличится до 20 Мб, и еще 10 Мб уйдет в WAL — а это очень дорого.
Мы сделали так, чтобы менялся только тот чанк, в котором произошло изменение, а все остальные чанки использовались (shared) старой и новой версиями строки:
Shared TOAST – updateВ этом случае копируются не все TOAST-чанки. У нас создается новая версия только того чанка, который нужен. Также здесь мы реализовали еще и **in-place update**: если данные свою длину не меняли, мы пытаемся их оставить на месте и записать новое значение (своего рода diff) в inline (не в TOAST, а в heap).
В результате так же улучшился и доступ к TOAST. На графике ниже мы видим, что исчезла ступенька, в гордом одиночестве остались одни roles, то есть длинный ключ. А все остальные теперь не зависят от размера JSON, который здесь меняется от 0 до 1 Мб:
Shared TOAST – access results (IMDB). Было — стало.### Обновление JSONB
Частичное обновление JSONB с помощью SHARED TOAST мы изучали на синтетическом примере из-за простоты интерпретации результатов. Тестовые данные выглядели как key1, большой массив key2, key3, массив key4. Как и раньше, слева — оригинальный постгрес (master), а справа — с оптимизацией SHARED TOAST. Видно, что оптимизация привела к тому, что время обновления для коротких ключей перестало зависеть от размера JSONB, а время обновления для длинных (TOAST) ключей зависит только от **их** размера (не общего размера JSONB) На следующем рисунке заметно, что количество записей в журнал (WAL) при обновлении коротких и ключей среднего размера сильно уменьшилось.
Все оптимизации доступа к JSONB на одной картинке:
Step-by-step results (IMDB)Здесь слева — текущая версия постгреса , дальше мы делаем частичную декомпрессию, сортируем ключи, частично deTOAST’им, дальше делаем inline TOAST, shared TOAST — все 5 оптимизаций на одном графике. Тут мы видим насколько сильно вырастает производительность — изменения до 3-х порядков !
> **Нужно подчеркнуть, что здесь осталась полная совместимость с JSONB, то есть старый и новый JSONB могут сосуществовать, потому что JSONB внутренне расширяем. Его бинарный формат сделан так, что он сам понимает, какую версию JSONB читает.**
>
>
При этом мы не оптимизировали с длинными ключами (и вряд ли сможем). Но короткие ключи, те самые метаданные, за которые мы боролись, стали вести себя совсем по-другому. Теперь в том самом примере, с которого мы начинали (ID вне JSON и ID внутри JSON), ситуация улучшилась:
Видно небольшую просадку производительности (график желтого цвета чуть выше, чем красный). Она объясняется тем, что нам все-таки надо достать данные из JSON. И хотя время доступа к длинному ключа так и продолжает расти с ростом размера JSONB, ID можно держать внутри JSON. Конечно, держать снаружи лучше, но разница уже не такая, как была. По количеству прочитанных блоков разницы нет, вы читаете ID, который находится вне JSON, или читаете ID, который находится внутри JSON:
Резюме и ссылки
---------------
Так, шаг за шагом, мы оптимизировали JSONB, причем с обратной совместимостью. Это привело к значительному (в 10 раз) ускорению для SELECTs и гораздо более дешевому апдейту.
Это наталкивает на мысль, что мы находимся на правильном пути к OLTP JSONB. Можно действительно не только быстро читать, делать точечное чтение, но и апдейтить, чего не хватает многим людям. Если хотите попробовать сами, то все для этого найдете на [Github](https://github.com/postgrespro/postgres/tree/jsonb_shared_toast).
Тот же подход может быть применен к любым типам данных, у которых есть возможность рандомного доступа к частям, например, массивы, hstore, фильмы. Можно сделать документ pdf, в заголовке которого имеются ссылки на страницы, что позволит легко делать доступ к любой странице, не скачивая весь файл.
Можно сделать appendable bytea (бинарный тип), и там будет даже 1000-кратный рост производительности. Это доступно в отдельной [ветке](https://github.com/postgrespro/postgres/tree/bytea_appendable_toaster), можно потестировать, мы всегда готовы к сотрудничеству.
С обобщенным API для JSON мы сделали возможность реализовать GIN-индексы для JSON. Как известно, GIN-индекс существует только для JSONB, а с помощью этого API можно сделать и для JSON. Об этом у нас есть два обширных доклада: [раз](http://www.sai.msu.su/~megera/postgres/talks/json-webinar-2020.pdf) и [два](http://www.sai.msu.su/~megera/postgres/talks/json-build-2020.pdf). В них есть описание и других проектов, например, расширение синтаксиса, новые индексы, обобщенный API для JSON.
Что дальше?
-----------
Мы хотим сделать больше бенчмарков. Понятно, что они должны быть либо общепризнанными, как YCSB (известный бенчмарк для неструктурированных БД) , либо типичными use cases.
И нам интересно, какие use cases есть у вас, как вы используете JSON — просто положить и взять? Или как-то еще? Что вы делаете с длинными массивами? Нам очень важно знать, что оптимизировать, чтобы мы не изобретали «сферического коня в вакууме».
Конечно, также надо сделать бенчмаркPostgres с Mongo — это очень важно. Я уже несколько раз встречал людей, которые используют Postgres, но часть данных держат в Mongo, потому что... Часто в Postgres люди используют реляционные структуру и данные, а в Mongo держат мусор — JSON. Улучшая Postgres, мы стремимся к тому, чтобы часть «монгоидов» все-таки пришла к Postgres. Нам очень важно работать с реальными пользователями.
Еще мы хотим **расширить подход shared TOAST**, чтобы поддерживать строки, массивы и массивы jsonb. Сейчас мы поддерживаем только корневые объекты, а надо идти по иерархии, потому что JSON может быть развесистым деревом, и было бы классно вытаскивать не всё, а только определенные веточки.
Предстоит большая работа по **pluggable TOAST**. Потому что пока неясно, как всё, о чем я рассказал, интегрировать в ядро Postgres, то есть отдать сообществу. Мало сделать ссылку на GitHub и сказать — берите. Надо бороться за то, чтобы сообщество это приняло.
И дальше нужно понять, как интегрировать этот все в CORE. Как сделать новый API, как сделать так, чтобы TOAST знал внутреннее устройство типа данных? Как лучше сжимать данные каждого типа? Например, если это просто integer, то с ним можно ничего не делать. Если это JSON, то надо использовать то, что мы сделали. Для массива нужно что-то другое.
Вообще стоит подумать над новым storage, в котором вообще нет TOAST, например, WiredElephant – storage, оптимизированный для древоподобных структур, в которых есть большие атрибуты.
Нам нужны Ваши кейсы — тестовые данные и запросы! Если вы можете анонимизировать их и предоставить нам, будем рады сотрудничеству.
Видео моего выступления на HighLoad ++ Весна 2021:
> Следующее повышение цен на [HighLoad++ Foundation 2022](https://clck.ru/anwbe) — 1 февраля. Вы можете забронировать [билеты](https://clck.ru/anwd7) и выкупить их позже по той же цене. Планируйте свое участие — [расписание](https://clck.ru/anwcQ) и полный [список тем с тезисами](https://clck.ru/anwcg) уже на сайте. Конференция пройдет 17 и 18 марта в Москве в Крокус Экспо.
>
> | https://habr.com/ru/post/646987/ | null | ru | null |
# SSL-сертификаты от Let's Encrypt с cert-manager в Kubernetes
В этой статье я расскажу о том, как автоматизировать заказ и продление сертификатов от Let’s Encrypt (и не только) для Ingress’а в Kubernetes с помощью дополнения cert-manager. Но начну с краткого введения в суть проблемы.
Немного ликбеза
---------------
Протокол HTTP, разработанный в начале 90-х годов прошлого века, вошёл в нашу повседневную жизнь настолько плотно, что тяжело представить хотя бы день без его использования. Однако сам по себе он не обеспечивает даже минимальный уровень безопасности при обмене информации между пользователем и веб-сервером. На помощь приходит HTTPS («S» — secure): используя упаковку передаваемых данных в SSL/TLS, этот протокол неплохо себя зарекомендовал в защите информации от перехвата и активно пропагандируется индустрией.
Например, Google с 2014 года [придерживается](https://security.googleblog.com/2014/08/https-as-ranking-signal_6.html) позиции «HTTPS везде» и даже понижает приоритет сайтам без него в поисковой выдаче. Не обходит стороной эта «пропаганда» и рядовых потребителей: современные браузеры предупреждают своих пользователей о наличии и корректности SSL-сертификатов у посещаемых сайтов.
Стоимость сертификата для личного сайта начинается с десятков долларов. Не всегда покупка его оправдана и целесообразна. Благо, с конца 2015 года доступна бесплатная альтернатива в виде сертификатов [Let’s Encrypt](https://letsencrypt.org/) (LE). Этот некоммерческий проект был создан энтузиастами из Mozilla для того, чтобы покрыть большую часть интернет-сайтов шифрованием.
Центр сертификации выписывает сертификаты типа [domain-validated](https://en.wikipedia.org/wiki/Domain-validated_certificate) (самые простые среди имеющихся на рынке) сроком действия в 90 дней, и уже не первый год возможен выпуск так называемого wildcard-сертификата на несколько поддоменов.
Для получения сайтом сертификата используются алгоритмы, описанные в протоколе [Automated Certificate Management Environment](https://en.wikipedia.org/wiki/Automated_Certificate_Management_Environment) (ACME), созданного специально для Let's Encrypt. При его использовании подтверждение владения доменом осуществляется запросами через размещение определенного HTTP-кода (называется *HTTP-01*) или установку DNS-записей *(DNS-01)* — подробнее о них будет ниже.
Cert-manager
------------
[Cert-manager](https://cert-manager.io/) — специальный проект для Kubernetes, представляющий собой набор CustomResourceDefinitions (отсюда [ограничение](https://cert-manager.io/docs/installation/kubernetes/) на минимально поддерживаемую версию K8s — v1.12) для конфигурации CA (удостоверяющих центров) и непосредственного заказа сертификатов. Установка CRD в кластер тривиальна и [сводится](https://cert-manager.io/docs/installation/kubernetes/) к применению одного YAML-файла:
```
kubectl create ns cert-manager
kubectl apply -f https://github.com/jetstack/cert-manager/releases/download/v0.13.0/cert-manager.yaml
```
*([Существует](https://cert-manager.io/docs/installation/kubernetes/#installing-with-helm) также и возможность установки с помощью Helm.)*
Для инициирования процедуры заказа в кластере должны быть объявлены ресурсы центров сертификации (CA): `Issuer` или `ClusterIssuer`, — которые используются для подписи CSR (запросов на выпуск сертификата). Отличие первого ресурса от второго — в области видимости:
* `Issuer` может использоваться в рамках одного пространства имен,
* `ClusterIssuer` является глобальным объектом кластера.
Практика с cert-manager
-----------------------
### №1. Самоподписанный сертификат
Начнем с простейшего случая — заказа самоподписанного сертификата. Такой вариант довольно распространен, например, для динамических тестовых окружений для разработчиков или же в случае использования внешнего балансировщика, терминирующего SSL-трафик.
Ресурс `Issuer` будет выглядеть так:
```
apiVersion: cert-manager.io/v1alpha2
kind: Issuer
metadata:
name: selfsigned
spec:
selfSigned: {}
```
А чтобы выпустить сертификат, необходимо описать ресурс `Certificate`, где указывается, как произвести выпуск (см. раздел `issuerRef` ниже) и где размещен приватный ключ (поле `secretName`). После этого в Ingress потребуется сослаться на этот ключ (см. раздел `tls` в `spec`):
```
---
apiVersion: cert-manager.io/v1alpha2
kind: Certificate
metadata:
name: selfsigned-crt
spec:
secretName: tls-secret
issuerRef:
kind: Issuer
name: selfsigned
commonName: "yet-another.website"
dnsNames:
- "yet-another.website"
---
apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
name: app
spec:
tls:
- hosts:
- "yet-another.website"
secretName: tls-secret
rules:
- host: "yet-another.website"
http:
paths:
- path: /
backend:
serviceName: app
servicePort: 8080
```
Через несколько секунд после добавления этих ресурсов в кластер сертификат будет выписан. Увидеть соответствующий отчёт можно в выводе команды:
```
kubectl -n app describe certificate selfsigned-crt
...
Normal GeneratedKey 5s cert-manager Generated a new private key
Normal Requested 5s cert-manager Created new CertificateRequest resource "selfsigned-crt-4198958557"
Normal Issued 5s cert-manager Certificate issued successfully
```
Если посмотреть на сам ресурс секрета, то в нём лежат:
* приватный ключ `tls.key`,
* корневой сертификат `ca.crt`,
* наш самоподписанный сертификат `tls.crt`.
Содержимое этих файлов можно увидеть с помощью утилиты `openssl`, например, так:
```
kubectl -n app get secret tls-secret -ojson | jq -r '.data."tls.crt"' | base64 -d | openssl x509 -dates -noout -issuer
notBefore=Feb 10 21:01:59 2020 GMT
notAfter=May 10 21:01:59 2020 GMT
issuer=O = cert-manager, CN = yet-another.website
```
Стоит отметить, что в общем случае сертификату, выписанному с помощью такого `Issuer`, подключаемые клиенты **доверять не будут**. Причина проста: он не имеет CA *(см. [примечание на сайте проекта](https://cert-manager.io/docs/configuration/selfsigned/))*. Чтобы этого избежать, нужно указать в `Certificate` путь до файла секрета, где содержится `ca.crt`. Таковым может быть и корпоративный CA организации — чтобы подписать выпускаемые для Ingress сертификаты ключом, уже используемым для нужд других серверных служб/информационных систем.
### №2. Сертификат Let’s Encrypt с HTTP-валидацией
Для выпуска сертификатов LE, как упоминалось ранее, доступны [два типа подтверждения](https://letsencrypt.org/docs/challenge-types/) владения доменом: HTTP-01 и DNS-01.
Первый подход (HTTP-01) [заключается](https://cert-manager.io/docs/configuration/acme/http01/) в запуске небольшого веб-сервера отдельным deployment’ом, который будет отдавать в интернет по ссылке `http:///.well-known/acme-challenge/` некие данные, запрашиваемые с сервера сертификации. Следовательно, этот метод подразумевает доступность Ingress’а извне по 80 порту и разрешение DNS-записи домена в публичные IP-адреса.
Второй вариант проверки выпускаемого сертификата (DNS-01) [исходит](https://cert-manager.io/docs/configuration/acme/dns01/) из наличия API к DNS-серверу, где размещены записи домена. Issuer с помощью указанных токенов создает TXT-записи на домене, которые потом получает в ходе подтверждения ACME-сервер. Среди официально поддерживаемых DNS-провайдеров — CloudFlare, AWS Route53, Google CloudDNS и другие, в том числе и собственная реализация ([acme-dns](https://cert-manager.io/docs/configuration/acme/dns01/acme-dns/)).
**Примечание**: у Let’s Encrypt существуют довольно [строгие лимиты](https://letsencrypt.org/docs/rate-limits/) на запросы к ACME-серверам. Чтобы не попасть в длительный бан, для отладки рекомендуется использовать тип сертификата [letsencrypt-staging](https://letsencrypt.org/docs/staging-environment/) (отличие только в ACME-сервере).
Итак, опишем ресурсы:
```
apiVersion: cert-manager.io/v1alpha2
kind: Issuer
metadata:
name: letsencrypt
spec:
acme:
server: https://acme-staging-v02.api.letsencrypt.org/directory
privateKeySecretRef:
name: letsencrypt
solvers:
- http01:
ingress:
class: nginx
---
apiVersion: cert-manager.io/v1alpha2
kind: Certificate
metadata:
name: le-crt
spec:
secretName: tls-secret
issuerRef:
kind: Issuer
name: letsencrypt
commonName: yet-another.website
dnsNames:
- yet-another.website
```
Обратите внимание, что в качестве `server` у `acme` (в `Issuer`) указан адрес **staging**-сервера. Заменить его на боевой можно будет позже.
Применив эту конфигурацию, проследим весь путь заказа:
1. Создание `Certificate` породило новый ресурс `CertificateRequest`:
```
kubectl -n app describe certificate le-crt
...
Created new CertificateRequest resource "le-crt-1127528680"
```
2. В его описании — отметка о создании `Order`:
```
kubectl -n app describe certificaterequests le-crt-1127528680
…
Created Order resource app/le-crt-1127528680-1805948596
```
3. В `Order` описано, с какими параметрами проходит проверка и какой у неё текущий статус. Такая проверка осуществляется ресурсом `Challenge`:
```
kubectl -n app describe order le-crt-1127528680-1805948596
…
Created Challenge resource "le-crt-1127528680-1805948596-1231544594" for domain "yet-another.website"
```
4. Наконец, в подробностях этого ресурса содержится информация о статусе самой проверки:
```
kubectl -n app describe challenges le-crt-1127528680-1805948596-1231544594
...
Reason: Successfully authorized domain
...
Normal Started 2m45s cert-manager Challenge scheduled for processing
Normal Presented 2m45s cert-manager Presented challenge using http-01 challenge mechanism
Normal DomainVerified 2m22s cert-manager Domain "yet-another.website" verified with "http-01" validation
```
Если все условия были соблюдены (т.е. домен доступен снаружи, нет бана со стороны LE…) — меньше, чем через минуту, сертификат будет выпущен. В случае успеха в выводе `describe certificate le-crt` появится запись `Certificate issued successfully`.
Теперь можно смело менять адрес сервера на боевой (`https://acme-v02.api.letsencrypt.org/directory`) и перезаказывать уже настоящие сертификаты, подписанные не `Fake LE Intermediate X1`, а `Let's Encrypt Authority X3`.
Для этого сначала потребуется удалить ресурс `Certificate`: иначе никакие процедуры заказа не активируются, потому что сертификат уже есть и он актуален. Удаление секрета приведет к его немедленному возврату с сообщением в `describe certificate`:
```
Normal PrivateKeyLost 44s cert-manager Lost private key for CertificateRequest "le-crt-613810377", deleting old resource
```
Остается применить «боевой» манифест для `Issuer` с уже описанным выше `Certificate` (он не изменился):
```
apiVersion: cert-manager.io/v1alpha2
kind: Issuer
metadata:
name: letsencrypt
spec:
acme:
server: https://acme-v02.api.letsencrypt.org/directory
privateKeySecretRef:
name: letsencrypt
solvers:
- http01:
ingress:
class: nginx
```
После получения сообщения `Certificate issued successfully` в `describe` проверим его:
```
kubectl -n app get secret tls-secret -ojson | jq -r '.data."tls.crt"' | base64 -d | openssl x509 -dates -noout -issuer
notBefore=Feb 10 21:11:48 2020 GMT
notAfter=May 10 21:11:48 2020 GMT
issuer=C = US, O = Let's Encrypt, CN = Let's Encrypt Authority X3
```
### №3. Wildcard LE с валидацией через DNS
Усложним задачу, выписав сертификат сразу на все поддомены сайта и воспользовавшись на этот раз DNS-проверкой (через CloudFlare).
Для начала получим в панели управления CloudFlare токен для работы через API:
1. Profile → API Tokens → Create Token.
2. Выставляем права доступа следующим образом:
* Permissions:
+ Zone — DNS — Edit
+ Zone — Zone — Read
* Zone Resources:
+ Include — All Zones
3. Копируем полученный после сохранения токен (например: `y_JNkgQwkroIsflbbYqYmBooyspN6BskXZpsiH4M`).
Создадим Secret, в котором будет храниться этот токен, и сошлемся на него в Issuer:
```
apiVersion: v1
kind: Secret
metadata:
name: cloudflare-api-token
type: Opaque
stringData:
api-token: y_JNkgQwkroIsflbbYqYmBooyspN6BskXZpsiH4M
---
apiVersion: cert-manager.io/v1alpha2
kind: Issuer
metadata:
name: letsencrypt
spec:
acme:
server: https://acme-v02.api.letsencrypt.org/directory
privateKeySecretRef:
name: letsencrypt
solvers:
- dns01:
cloudflare:
email: my-cloudflare-acc@example.com
apiTokenSecretRef:
name: cloudflare-api-token
key: api-token
---
apiVersion: cert-manager.io/v1alpha2
kind: Certificate
metadata:
name: le-crt
spec:
secretName: tls-secret
issuerRef:
kind: Issuer
name: letsencrypt
commonName: yet-another.website
dnsNames:
- "yet-another.website"
- "*.yet-another.website"
```
*(Не забудьте про использование staging, если экспериментируете!)*
Пройдем процедуру подтверждения владения доменом:
```
kubectl -n app describe challenges.acme.cert-manager.io le-crt-613810377-1285319347-3806582233
...
Status:
Presented: true
Processing: true
Reason: Waiting for dns-01 challenge propagation: DNS record for "yet-another.website" not yet propagated
State: pending
Events:
Type Reason Age From Message
---- ------ ---- ---- -------
Normal Started 54s cert-manager Challenge scheduled for processing
Normal Presented 53s cert-manager Presented challenge using dns-01 challenge mechanism
```
В панели появится TXT-запись:
… а через некоторое время статус сменится на:
```
Domain "yet-another.website" verified with "dns-01" validation
```
Убедимся в том, что сертификат валиден для любого поддомена:
```
kubectl -n app get secret tls-secret -ojson | jq -r '.data."tls.crt"' | base64 -d | openssl x509 -dates -noout -text |grep DNS:
DNS:*.yet-another.website, DNS:yet-another.website
```
Валидация по DNS, как правило, происходит не быстро, так как для большинства DNS-провайдеров характерен период обновления данных, показывающий, сколько времени пройдёт с момента изменения DNS-записи до фактического обновления всех DNS-серверов провайдера. Однако стандарт ACME предусматривает и комбинацию двух вариантов проверок, что можно использовать для ускорения получения сертификата на основной домен. В этом случае описание `Issuer` будет следующим:
```
apiVersion: cert-manager.io/v1alpha2
kind: Issuer
metadata:
name: letsencrypt
spec:
acme:
server: https://acme-v02.api.letsencrypt.org/directory
privateKeySecretRef:
name: letsencrypt
solvers:
- selector:
dnsNames:
- "*.yet-another.website"
dns01:
cloudflare:
email: my-cloudflare-acc@example.com
apiTokenSecretRef:
name: cloudflare-api-token
key: api-token
- selector:
dnsNames:
- "yet-another.website"
http01:
ingress:
class: nginx
```
Если применить эту конфигурацию, будут созданы два ресурса `Challenge`:
```
kubectl -n app describe orders le-crt-613810377-1285319347
…
Normal Created 3m29s cert-manager Created Challenge resource "le-crt-613810377-1285319347-3996324737" for domain "yet-another.website"
Normal Created 3m29s cert-manager Created Challenge resource "le-crt-613810377-1285319347-1443470517" for domain "yet-another.website"
```
### №4. Использование специальных аннотаций Ingress
Помимо прямого пути по созданию сертификатов в cert-manager есть возможность воспользоваться компонентом под названием [ingress-shim](https://cert-manager.io/docs/usage/ingress/#supported-annotations) и явно не создавать ресурсы `Certificate`. Идея заключается в том, что с помощью специальных аннотаций Ingress’а сертификат будет автоматически заказан с помощью указанного в них `Issuer`. В результате получается примерно следующий ресурс Ingress’а:
```
apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
annotations:
cert-manager.io/cluster-issuer: letsencrypt
spec:
tls:
- hosts:
- "yet-another.website"
secretName: tls-secret
rules:
- host: "yet-another.website"
http:
paths:
- path: /
backend:
serviceName: app
servicePort: 8080
```
Для корректной работы тут достаточно только наличия Issuer’а, то есть создавать на одну сущность меньше.
Кроме того, существует [**устаревшая**](https://cert-manager.io/docs/usage/ingress/#optional-configuration) аннотация [kube-lego](https://github.com/jetstack/kube-lego) — `kubernetes.io/tls-acme: "true"`, — которая требует задания `Issuer` по умолчанию при установке cert-manager с помощью параметров Helm (или в параметрах запуска контейнера менеджера).
Мы в компании не пользуемся этими вариантами и не можем их посоветовать ввиду непрозрачности используемых подходов к заказу SSL-сертификатов (а заодно — и к возникающих разного рода [проблем](https://github.com/jetstack/cert-manager/issues/2314)), но все же решили упомянуть в статье для более полной картины.
Вместо заключения
-----------------
Путём несложных манипуляций с CRD мы научились выписывать автопродляемые, самоподписанные и бесплатные SSL-сертификаты от проекта Let’s Encrypt для доменов сайтов, запущенных в рамках Ingress’ов в Kubernetes-кластерах.
В статье приведены примеры решения наиболее частых в нашей практике задач. Однако функции cert-manager не ограничиваются описанными выше возможностями. На сайте утилиты можно найти примеры работы с другими сервисами — например, [связка с Vault](https://cert-manager.io/docs/configuration/vault/) или же [использование внешних выпускающих центров](https://cert-manager.io/docs/configuration/external/) (issuers).
P.S.
----
Читайте также в нашем блоге:
* «[Введение в сетевые политики Kubernetes для специалистов по безопасности](https://habr.com/ru/company/flant/blog/443190/)»;
* «[Kubernetes tips & tricks: персонализированные страницы ошибок в NGINX Ingress](https://habr.com/ru/company/flant/blog/445596/)»;
* «[Обзор и сравнение контроллеров Ingress для Kubernetes](https://habr.com/ru/company/flant/blog/447180/)». | https://habr.com/ru/post/496936/ | null | ru | null |
# Быстрый, мощный интерфейс на Python
### И минимум зависимостей
DearPyGuiDear PyGui принципиально отличается от других фреймворков GUI Python. Рендеринг на GPU, более 70 виджетов, встроенная поддержка асинхронности — это лишь некоторые возможности Dear PyGui. Руководством по работе с этим пакетом делимся к старту курса [по разработке на Python](https://skillfactory.ru/python-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_py_080921&utm_term=lead).
---
Парадигма Retained Mode позволяет создавать чрезвычайно динамичные интерфейсы. Dear PyGui не использует нативные виджеты, а рисует с помощью видеокарты компьютера, как PyQt (используя API рендеринга DirectX11, Metal и Vulkan).
Почему Dear PyGui?
------------------
По сравнению с другими библиотеками Python GUI Dear PyGui уникален:
* Рендеринг на GPU.
* Простая встроенная поддержка асинхронных функций.
* Полное управление темами и стилями.
* Простое встроенное окно логирования.
* 70+ виджетов, сотни их комбинаций.
* Подробная документация, примеры и беспрецедентная поддержка.
Основные моменты
----------------
* Темы — 10 встроенных тем и система пользовательских тем.
* Graphing — API для работы с графиками (обертка ImPlot).
* Canvas — низкоуровневый API для рисования.
* Logging — API логирования.
* Виджеты — просто прокрутите вниз, чтобы увидеть их.
Установка
---------
Убедитесь, что у вас установлен как минимум Python 3.7 (64 бит).
```
pip install dearpygui
# или
pip3 install dearpygui
```
### Зависимости
* [Dear ImGui](https://github.com/ocornut/imgui)
* [CPython](https://github.com/python/cpython)
* [ImPlot](https://github.com/epezent/implot)
* [CLI11](https://github.com/CLIUtils/CLI11)
Начинаем писать GUI
-------------------
Dear PyGui предоставляет разработчикам python простой способ создания быстрых и мощных графических интерфейсов для скриптов. Dear PyGui состоит из окна программы, окон и виджетов. Окно программы является главным окном вашей программы и создаётся в конце основного скрипта вызовом start\_dearpygui().
```
from dearpygui.core import *
def save_callback(sender, data):
print("Save Clicked")
add_text("Hello, world")
add_button("Save", callback=save_callback)
add_input_text("string", default_value="Quick brown fox")
add_slider_float("float", default_value=0.273, max_value=1)
start_dearpygui()
```
Результат:
Вывод В приведённом ниже примере программы показано окно программы и ещё одно окно, в котором с помощью встроенной функции документации отображается документация:
```
from dearpygui.core import *
set_main_window_size(800, 800)
show_about()
show_documentation()
# when running this code please look at the about window and it will report which version of Dear PyGUI is running
# Even if you just did a pip install please ensure you your environment is using the latest package
start_dearpygui()
```
Встроенная документацияDear PyGui состоит из двух модулей: dearpygui.core и dearpygui.simple.
* dearpygui.core содержит базовую функциональность Dear PyGUI. Через ядро можно делать всё. На самом деле это расширение на языке Си, просто обёрнутое в модуль.
* dearpygui.simple содержит обёртки и утилиты уже из кода ядра для удобства работы с Dear PyGui.
### Инструменты разработки
В Dear PyGui есть полезные инструменты разработки. Метод show\_source() принимает имя входного файла Python.
```
from dearpygui.core import *
show_documentation()
show_debug()
show_about()
show_metrics()
show_source("main.py") # replace "main.py" with your python file name
show_logger()
start_dearpygui()
```
### Встроенное логирование
Мощный инструмент разработки — Logger, он вызывается методом show\_logger(). Уровней логирования 6: Trace, Debug, Info, Warning, Error, Off. Логгер выведет установленный уровень и отфильтрует все уровни ниже.
ЛогированиеУровень лога mvTRACE покажет все команды.
```
from dearpygui.core import *
show_logger()
set_log_level(mvTRACE)
log("trace message")
log_debug("debug message")
log_info("info message")
log_warning("warning message")
log_error("error message")
start_dearpygui()
```
### Пишем виджеты и контейнеры
Элементы библиотеки можно разделить на:
* обычные предметы: поля ввода, кнопки;
* контейнеры (окно, всплывающее окно, всплывающая подсказка, элемент-потомок);
* элементы макета (группа, следующая колонка (next\_column)).
Элементы добавляются командами с префиксом add\_.
ВиджетыКаждый элемент должен иметь уникальное имя. По умолчанию, если это применимо, имя станет меткой элемента. При желании можно изменить метку:
* Поставьте ## после имени (например displayed\_name##unique\_part). Всё после ## в отображаемом имени будет скрыто.
* Ключевое слово label, которое отобразит метку вместо имени.
Некоторые имена элементов автоматически генерируются для элементов без аргументов имени в функции (т. е. same\_line). Но у них есть необязательное ключевое слово name, и его можно заполнить, когда понадобится ссылка на элемент.
```
from dearpygui.core import *
add_button("Apply")
add_same_line(spacing=10)
add_button("Apply##1")
add_same_line(spacing=10, name="sameline1")
add_button("Apply2", label="Apply")
add_spacing(count=5, name="spacing1")
add_button("Apply##3")
start_dearpygui()
```
Контекстные менеджеры dearpygui.simple автоматизируют вызов функции end, позволяют сворачивать код и в самом коде показывают иерархию.
По умолчанию элементы создаются в порядке их описания в коде.
Но, указав контейнер parent, элементы можно добавлять не по порядку. parent вставляет виджет в конец списка дочерних элементов родителя. before в сочетании с ключевым словом parent помещает один элемент перед другим в списке элементов-потомков.
```
from dearpygui.core import *
from dearpygui.simple import *
add_text("First coded widget")
add_text("This is some text on window 2", parent="window 2")
# we can even specify the parent before it was coded
add_text("This is some text on child 1", parent="child 1")
# we can even specify the parent before it was coded
with window("window 1"):
# simple
with child("child 1"):
# simple
add_checkbox("Checkbox")
# this is a input item added inside of the child
add_checkbox("Last coded widget", parent="MainWindow", before="First coded widget")
add_checkbox("Last coded widget 2", parent="child 1", before="Checkbox")
# empty window
with window("window 3"): # simple
pass
start_dearpygui()
```
### Виджеты
Каждый виджет ввода имеет значение, которое можно задать с помощью ключевого слова default\_value при создании или во время выполнения команды set\_value. Для доступа к значению виджета можно использовать команду get\_value. Мы также можем передавать значение виджета непосредственно в переменную python и из неё.
```
from dearpygui.core import *
my_var = True
add_checkbox("Radio Button", default_value=my_var)
print("Radio Button Value: ", get_value("Radio Button"))
print("my_var Value: ", my_var)
set_value("Radio Button", False)
print("Radio Button Value: ", get_value("Radio Button"))
print("my_var Value: ", my_var)
my_var = get_value("Radio Button")
print("Radio Button Value: ", get_value("Radio Button"))
print("my_var Value: ", my_var)
start_dearpygui()
```
### Виджеты и обратные вызовы окна
Каждый элемент ввода имеет обратный вызов, который выполняется при взаимодействии с виджетом.
Обратные вызовы добавляют виджетам функциональность. Они могут присваиваться до или после создания элемента функцией set\_item\_callback, как в коде ниже.
> Каждый обратный вызов должен принимать аргументы sender и data.
>
>
sender сообщает обратному вызову имя элемента, которым он вызывается.
Аргумент data применяется разными стандартными обратными вызовами для отправки дополнительных данных через определение callback\_data.
Виджеты оконного типа имеют специальные обратные вызовы, которые срабатывают при таких событиях, как изменение размера или закрытие окна. Обратные вызовы для конкретных окон могут быть применены к виджету любого типа окна. on\_close будет запускать обратный вызов, назначенный ключевому слову, при закрытии окна, а set\_resize\_callback() будет запускаться при каждом изменении размера контейнера и может быть установлен на любое конкретное окно ключевым словом handler, по умолчанию это MainWindow.
Если вы хотите, чтобы обратный вызов выполнялся на каждом фрейме, воспользуйтесь set\_render\_callback().
```
from dearpygui.core import *
from dearpygui.simple import *
def close_me(sender, data):
log_debug(f"{sender} window has been closed")
def render_me(sender, data):
log_debug(f"window {sender} has ran a render callback")
def resize_me(sender, data):
log_debug(f"window {sender} has ran a rezise callback")
show_logger() # were going to use the logger to display callback replies
with window("Tester", on_close=close_me): # simple
add_text('resize this window resize callback will occur')
add_text('close this window using the "x" button and a close callback will occur')
set_render_callback(render_me)
set_resize_callback(resize_me, handler="Tester")
start_dearpygui()
```
### Добавляем и удаляем виджеты в рантайме
С помощью Dear PyGui вы можете динамически добавлять и удалять любые элементы во время выполнения программы. Это можно сделать, используя обратный вызов для выполнения команды add\_\* нужного элемента, указав родителя, к которому будет принадлежать элемент. По умолчанию, если не указан родительский элемент, виджет будет добавлен в MainWindow.Используя ключевое слово before при добавлении элемента, вы можете контролировать, перед каким элементом родительской группы будет находиться новый элемент. По умолчанию новый виджет помещается в конец.
### Хранилище значений и данных
Когда новый виджет добавлен, в системное хранилище добавляется некое значение. По умолчанию идентификатор этого значения — имя виджета. Значения извлекаются из системы значений с помощью get\_value("source name"). Меняются значения вручную, методом set\_value("source name"). Чтобы виджеты разных типов значений могли использовать одно и то же значение в системе хранения, сначала должно быть создано большее значение.
> Помните, что вы можете хранить любой объект Python в хранилище данных, даже пользовательские типы данных.
>
>
Вот так можно хранить отображение:
```
from dearpygui.core import *
def store_data(sender, data):
custom_data = {
"Radio Button": get_value("Radio Button"),
"Checkbox": get_value("Checkbox"),
"Text Input": dget_value("Text Input"),
}
add_data("stored_data", custom_data)
def print_data(sender, data):
log_debug(get_data("stored_data"))
show_logger()
show_debug()
add_radio_button("Radio Button", items=["item1", "item2"])
add_checkbox("Checkbox")
add_input_text("Text Input")
add_button("Store Data", callback=store_data)
add_button("Print Data", callback=print_data)
start_dearpygui()
```
### Меню
Очень важный виджет для функциональности GUI — это бар меню. Строки меню всегда отображаются в верхней части окна и состоят в основном из:
1. Лента главного меню.
2. Выпадающие подменю.
3. Конкретные элементы меню.
Элементы меню добавляются слева направо, а элементы подменю — сверху вниз. Они могут быть вложенными, насколько это необходимо:
```
from dearpygui.core import *
from dearpygui.simple import *
def print_me(sender, data):
log_debug(f"Menu Item: {sender}")
show_logger()
with menu_bar("Main Menu Bar"): # simple
with menu("File"): # simple
add_menu_item("Save", callback=print_me)
add_menu_item("Save As", callback=print_me)
with menu("Settings"): # simple
add_menu_item("Setting 1", callback=print_me)
add_menu_item("Setting 2", callback=print_me)
add_menu_item("Help", callback=print_me)
with menu("Widget Items"):
add_checkbox("Pick Me", callback=print_me)
add_button("Press Me", callback=print_me)
add_color_picker4("Color Me", callback=print_me)
start_dearpygui()
```
### Диалоги выбора файлов и каталогов
Диалог выбора каталога вызывается select\_directory\_dialog(), которому необходим обратный вызов.
Файловые диалоги вызываются open\_file\_dialog(), которому должен быть задан обратный вызов. Аргумент data возвращаемого обратного вызова будет заполнен списком строк из пути к папке и к файлу. Расширения — это дополнительное ключевое слово к диалогу файлов, которое позволяет отфильтровать файлы в диалоге по расширениям.
```
from dearpygui.core import *
def file_picker(sender, data):
open_file_dialog(callback=apply_selected_file, extensions=".*,.py")
def apply_selected_file(sender, data):
log_debug(data) # so we can see what is inside of data
directory = data[0]
file = data[1]
set_value("directory", directory)
set_value("file", file)
set_value("file_path", f"{directory}\\{file}")
show_logger()
add_button("Directory Selector", callback=file_picker)
add_text("Directory Path: ")
add_same_line()
add_label_text("##filedir", source="directory", color=[255, 0, 0])
add_text("File: ")
add_same_line()
add_label_text("##file", source="file", color=[255, 0, 0])
add_text("File Path: ")
add_same_line()
add_label_text("##filepath", source="file_path", color=[255, 0, 0])
start_dearpygui()
```
### Графики
В Dear PyGui есть «простые графики» и «графики», оба типа могут быть динамическими.
ГрафикиПростые графики берут список и строят данные по оси y в зависимости от количества элементов в списке. Это могут быть линейные графики или гистограммы.
В «графиках» используются координаты x и y. Вызывать их нужно командой add\_plot(), затем данные могут быть добавлены в виде линейного или рассеянного ряда. Вот список возможностей:
* Клик с перетаскиванием панорамирует график.
* Клик с перетаскиванием по оси панорамирует график в одном направлении.
* Двойной клик масштабирует данные.
* Правый клик и перетаскивание увеличивают область.
* Двойной правый клик открывает настройки.
* Shift + правый клик и перетаскивание масштабирует область, заполняющую текущую ось.
* Прокрутка колёсика позволяет рассмотреть детали.
* Прокрутка колёсика по оси увеличивает только по этой оси.
* Можно переключать и скрывать наборы данных на легенде.
Простые графики можно сделать динамическими, изменив значение вызова plot с помощью set\_value().
Управление графикамиДинамическая функция может очищать график и добавлять новые данные с помощью обратного вызова, например для рендеринга или обратного вызова элемента.
```
from dearpygui.core import *
from math import cos
def plot_callback(sender, data):
# keeping track of frames
frame_count = get_data("frame_count")
frame_count += 1
add_data("frame_count", frame_count)
# updating plot data
plot_data = get_data("plot_data")
if len(plot_data) > 2000:
frame_count = 0
plot_data.clear()
plot_data.append([3.14 * frame_count / 180, cos(3 * 3.14 * frame_count / 180)])
add_data("plot_data", plot_data)
# plotting new data
clear_plot("Plot")
add_line_series("Plot", "Cos", plot_data, weight=2)
add_plot("Plot", height=-1)
add_data("plot_data", [])
add_data("frame_count", 0)
set_render_callback(plot_callback)
start_dearpygui()
```
Представления графиков### Рисование и холст
В Dear PyGui есть низкоуровневый API, хорошо подходящий для рисования примитивов, пользовательских виджетов и даже динамических рисунков.
Рисунок запускается вызовом add\_drawing(). Начало холста — в левом нижнем углу.
Рисунки имеют масштаб, начало и размер, к которым можно получить доступ и задать их. Масштаб — это множитель значений элементов x и y. Размер указывается в пикселях. На рисунках можно отображать .png, .jpg или .bmp. Изображения рисуются с помощью функции draw\_image().
Хотя рисунки можно сделать динамичными, очищая и перерисовывая всё заново, предлагается метод эффективнее: чтобы сделать рисунок динамичным, мы должны использовать ключевое слово tag для обозначения элементов, которые хотим перерисовать. Затем нужно просто вызвать команду рисования, используя тот же тег. Это позволит удалить только один элемент и перерисовать его с помощью новой команды.
```
from dearpygui.core import *
def on_render(sender, data):
counter = get_data("counter")
counter += 1
modifier = get_data("modifier")
if counter < 300:
modifier += 1
elif counter < 600:
modifier -= 1
else:
counter = 0
modifier = 2
xpos = 15 + modifier*1.25
ypos = 15 + modifier*1.25
color1 = 255 - modifier*.8
color3 = 255 - modifier*.3
color2 = 255 - modifier*.8
radius = 15 + modifier/2
segments = round(35-modifier/10)
draw_circle("Drawing_1", [xpos, ypos], radius, [color1, color3, color2, 255], segments, tag="circle##dynamic")
add_data("counter", counter)
add_data("modifier", modifier)
add_data("counter", 0)
add_data("modifier", 2)
add_drawing("Drawing_1", width=700, height=700)
set_render_callback(on_render)
start_dearpygui()
```
### Дельта-время и внутренние часы
Dear PyGui имеет встроенные часы для проверки общего времени работы. get\_total\_time(), возвращается общее время работы в секундах.
Также с помощью команды get\_delta\_time() мы можем проверить время между кадрами рендеринга в секундах.
```
from dearpygui.core import *
def on_render(sender, data):
delta_time = str(round(get_delta_time(), 4))
total_time = str(round(get_total_time(), 4))
set_value("delta_time", delta_time)
set_value("total_time", total_time)
add_text("Total Time: ")
add_same_line()
add_label_text("##total_time_text", source="total_time")
add_text("Delta Time: ")
add_same_line()
add_label_text("##delta_time_text", source="delta_time")
set_render_callback(callback=on_render)
start_dearpygui()
```
### Таблицы
Dear PyGui имеет простой API таблиц, который хорошо подходит для статических и динамических таблиц.
ТаблицыВиджет таблицы запускается вызовом add\_table(). Для редактирования виджета таблицы мы можем использовать методы add\_row(), add\_column(), которые добавят строку/столбец к последнему слоту таблицы.
В качестве альтернативы мы можем вставить строки/столбцы с помощью insert\_row(), insert\_column(). Столбцы и строки вставляются в соответствии с их индексным аргументом. Если указанный индекс уже существует, то выходящие столбцы/строки будут удалены, а новая строка/столбец будет вставлена по указанному индексу.
Кроме того, при добавлении или вставке строки/столбца неуказанные ячейки по умолчанию окажутся пустыми. Кроме того, заголовки и ячейки могут быть переименованы, а их значения изменены. Ячейки можно выбирать. Это означает, что мы можем применить обратный вызов к таблице и получить через отправителя данные о том, какая ячейка была выбрана, и даже получить текст внутри ячейки.
```
from dearpygui.core import *
def table_printer(sender, data):
log_debug(f"Table Called: {sender}")
coord_list = get_table_selections("Table Example")
log_debug(f"Selected Cells (coordinates): {coord_list}")
names = []
for coordinates in coord_list:
names.append(get_table_item("Table Example", coordinates[0], coordinates[1]))
log_debug(names)
show_logger()
add_table("Table Example", ["Header 0", "Header 1"], callback=table_printer)
add_row("Table Example", ["awesome row", "text"])
add_row("Table Example", ["super unique", "unique text"])
add_column("Table Example", "Header 3", ["text from column", "text from column"])
add_row("Table Example", ["boring row"])
start_dearpygui()
```
### Опрос устройств ввода
Опрос ввода в Dear PyGui делается вызовом команды опроса в функции. Функция должна быть установлена на обратный вызов рендеринга окна, чтобы опрос происходил, когда это окно активно. Обратные вызовы рендеринга выполняются каждый кадр, Dear PyGui может опрашивать на предмет ввода между кадрами.
Опрос устройств вводаВот список функций опроса* get\_mouse\_drag\_delta()
* get\_mouse\_pos()
* is\_key\_down()
* is\_key\_pressed()
* is\_key\_released()
* is\_mouse\_button\_clicked()
* is\_mouse\_button\_double\_clicked()
* is\_mouse\_button\_down()
* is\_mouse\_button\_dragging()
* is\_mouse\_button\_released()
* set\_key\_down\_callback()
* set\_key\_press\_callback()
* set\_key\_release\_callback()
* set\_mouse\_click\_callback()
* set\_mouse\_double\_click\_callback()
* set\_mouse\_down\_callback()
* set\_mouse\_drag\_callback()
* set\_mouse\_wheel\_callback()
* set\_render\_callback()
* set\_resize\_callback()
Подробности смотрите в [описании](https://hoffstadt.github.io/DearPyGui/) API. Чтобы добиться желаемого поведения, комбинируйте методы.
```
from dearpygui.core import *
def main_callback(sender, data):
set_value("Mouse Position", str(get_mouse_pos()))
if is_key_down(mvKey_A):
set_value("A key Down", "True")
else:
set_value("A key Down", "False")
if is_key_pressed(mvKey_A):
set_value("A key Pressed", "True")
else:
set_value("A key Pressed", "False")
if is_key_released(mvKey_A):
set_value("A key Released", "True")
else:
set_value("A key Released", "False")
if is_mouse_button_dragging(mvMouseButton_Left, 10):
set_value("Left Mouse Dragging", "True")
else:
set_value("Left Mouse Dragging", "False")
if is_mouse_button_clicked(mvMouseButton_Left):
set_value("Left Mouse Clicked", "True")
else:
set_value("Left Mouse Clicked", "False")
if is_mouse_button_double_clicked(mvMouseButton_Left):
set_value("Left Mouse Double Clicked", "True")
else:
set_value("Left Mouse Double Clicked", "False")
if is_key_down(mvKey_Shift) and is_mouse_button_clicked(mvMouseButton_Left):
set_value("Shift + Left Mouse Clicked", "True")
else:
set_value("Shift + Left Mouse Clicked", "False")
add_label_text("A key Down", value="False", color=[0, 200, 255])
add_label_text("A key Pressed", value="False", color=[0, 200, 255])
add_label_text("A key Released", value="False", color=[0, 200, 255])
add_spacing()
add_label_text("Mouse Position", value="(0,0)", color=[0, 200, 255])
add_label_text("Left Mouse Clicked", value="False", color=[0, 200, 255])
add_label_text("Left Mouse Dragging", value="False", color=[0, 200, 255])
add_label_text("Left Mouse Double Clicked", value="False", color=[0, 200, 255])
add_label_text("Shift + Left Mouse Clicked", value="False", color=[0, 200, 255])
set_render_callback(main_callback)
start_dearpygui()
```
### Многопоточность и асинхронные функции
Для вычислений и обратных вызовов, требующих длительного времени, может быть полезно реализовать асинхронные функции или функции, выполняемые в отдельных потоках. Просто вызовите run\_async\_function().
> Важно отметить, что запущенные с помощью команды async функции не могут вызывать другие функции API Dear PyGui.
>
>
Асинхронные функции не могут получить доступ к add\_data() или get\_data(). Поэтому, когда необходимо передать данные в асинхронную функцию, вы должны использовать аргументы с ключевыми словами data и return handler. Любой объект Python можно сделать доступным для функции async, отправив его в функцию через data. Кроме того, любые возвращаемые данные из функции Async будут доступны через ввод data указанного обратного вызова.
```
from dearpygui.core import *
from time import sleep
def long_async_preparer(data, sender):
floaty = get_value("Async Input Data")
run_async_function(long_callback, floaty, return_handler=long_async_return)
def long_callback(sender, data):
sleep(3)
return data * 2
def long_async_return(sender, data):
log_debug(data)
def long_callback2(sender, data):
sleep(3)
log_debug(data * 2)
show_logger()
add_text(
"input a number and see the logger window for the output of the long callback that would normally freeze the GUI")
add_input_float("Async Input Data", default_value=1.0)
add_button("long Function", callback=long_callback2, callback_data=get_value("Async Input Data"), tip="This is the long callback that will freeze the gui")
add_button("long Asynchronous Function", callback=long_async_preparer, tip="this will not a freeze the GUI")
start_dearpygui()
```
Когда вызывается метод асинхронной функциональности, создаётся пул потоков. Настраиваются время ожидания и количество потоков.
Используя set\_thread\_count(), мы можем установить количество потоков в пуле, использовать set\_threadpool\_high\_performance(), чтобы указать пулу потоков максимум потоков на компьютере пользователя. Имейте в виду, что при вызове асинхронных функций процессор будет работать на 100 %. Установить время ожидания для пула потоков можно с помощью set\_threadpool\_timeout(). Это уничтожит пул и освободит ресурсы через заданное время.
### Темы и стили
Темы и стилизация виджетов могут применяться к отдельному виджету или приложению в целом. Вот примеры атрибутов стиля:
* размер шрифта;
* цветовая схема приложения;
* скругление углов.
Темы и стилиПримеры
-------
[Репозиторий](https://github.com/Pcothren/DearPyGui-Examples.git) демонстраций Dear PyGui.
Для установки необходимых зависимостей запустите в репозитории
```
pip install -r requirements.txt
```
или
```
pip3 install -r requirements.txt.
```
Заключение
----------
Dear PyGui — это простой и мощный фреймворк для создания графических интерфейсов пользователя с помощью скриптов на языке Python. Он рисует через GPU и работает на Windows 10, macOS и Linux, содержит функции графики, темы, API для пользовательских отрисовок и инструменты для разработки приложений.
DearPyGui оборачивает Dear ImGui, включает дополнительные виджеты и дополнения (графики, диалоги файлов, изображения, виджет редактирования текста и т. д.), поддерживает асинхронность, добавление элементов на холст, дополнительные инструменты отладки и т. д.
Планы [на 12 октября 2020]:
* Интерфейс в стиле ООП [[вот](https://github.com/mwerezak/DearPyGui-Obj) вариант].
* Гистограмма, круговая диаграмма и другие элементы.
* Улучшения для закрепления окон и двух вьюпортов.
* Виджет 3D.
* API персонализации виджетов.
Ссылки1. [Dear PyGui](https://pypi.org/project/dearpygui/0.1.0a18/).
2. [Dear PyGui на Github](https://hoffstadt.github.io/DearPyGui/).
3. [Примеры](https://github.com/Pcothren/DearPyGui-Examples).
4. [Документация](https://hoffstadt.github.io/DearPyGui/).
5. [Туториалы](https://hoffstadt.github.io/DearPyGui/tutorial.html).
Вот так на Python можно сделать достойный графический интерфейс. Язык продолжает развиваться, а благодаря лаконичности и простоте превращается в швейцарский нож программиста. Если разработка на Python вам интересна, [переходите](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_080921&utm_term=conc) на страницы наших курсов, чтобы увидеть, как мы готовим людей к началу карьеры [Python-разработчика](https://skillfactory.ru/python-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_py_080921&utm_term=conc).
Узнайте больше [здесь](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_080921&utm_term=conc).
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_080921&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_080921&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_080921&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_080921&utm_term=cat)
**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_080921&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_080921&utm_term=cat)
* [Курс «Математика для Data Science»](https://skillfactory.ru/matematika-dlya-data-science#syllabus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mat_080921&utm_term=cat)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/matematika-i-machine-learning-dlya-data-science?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_matml_080921&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/data-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_080921&utm_term=cat)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/machine-learning-i-deep-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_080921&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/machine-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_080921&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/ios-razrabotchik-s-nulya?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_ios_080921&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_080921&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_080921&utm_term=cat)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer-testirovshik-po?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_qaja_080921&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_080921&utm_term=cat)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-razrabotchik-na-unity-i-c-sharp?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_gamedev_080921&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algoritmy-i-struktury-dannyh?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_080921&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_080921&utm_term=cat)
* [Профессия Этичный хакер](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_080921&utm_term=cat)
**А также:**
* [Курс по DevOps](https://skillfactory.ru/devops-ingineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_080921&utm_term=cat) | https://habr.com/ru/post/576912/ | null | ru | null |
# journald вместо syslog
Давным-давно, когда были дебаты о том, стоит ли принимать в качестве init-системы systemd (с одной стороны удобно, с другой стороны, довольно токсичный автор...), вместе с systemd приехал и journald. В целом, он ощущался как аппендикс к systemd, и вместе с `ForwardToSyslog`, он мирно жил на серверах. Дефолтная конфигурация в целом устраивала, а всё нужное можно было по-старинке накрутить в syslog'е.
В одном из проектов у нас образовалась потребность в обработке большого числа логов, и мы решили попробовать journald вместо (r)syslog(d|-ng). Оказалось, что:
1. journald решает все наши проблемы
2. документации по нему подозрительно мало (особенно, в сравнении с systemd)
3. при том, что его поведение более-менее разумно, интуиция о том, как он работает, практически отсутствует и её надо набирать.
Так что в рамках этого поста я рассказываю про journald. Не про journalctl, а именно про `systemd-journald`, т.е. про демон, который логи собирает, хранит и ротирует.
Архитектура
-----------
journald принимает сообщения через специальный протокол. Есть библиотека для отправки туда логов (и большинство языко-специфичных фреймворков логгирования её поддерживают, на одном уровне с syslog, stderr, elastic и т.д.). Базовая функция этой библиотеки [sd\_journal\_send](https://manpages.debian.org/jessie/libsystemd-dev/sd_journal_send.3.en.html). Ещё journald может "выковыривать" логи из kmsg (его выводит команда `dmesg`), и всё. В отличие от многих других систем (logstash, graylog) journald не умеет бегать за файлами на файловой системе и "забирать" их.
systemd использует сервисы journald для отправки туда всевозможных вариантов логов от приложения, например, вывод в stdout и stderr. "запись stdout" - это функция именно systemd, а journald ждёт уже аккуратно подготовленных данных в свой сокет.
Полученные данные хранятся частично в оперативной памяти, и могут сохраняться в постоянное хранилище на диске с настраиваемым уровнем надёжности (flush, криптографическая целостность и т.д.). Файлы на диске - бинарные, индексированные. journald сам их ротирует, хотя, если вы "грохнете" архив, ничего страшного с точки зрения journald не случится. Главным клиентом к journald является journalctl, хотя есть и альтернативные клиенты (включая веб-интерфейсы). Ещё есть systemd-journald-remote, но в рамках нашей задачи это было не нужно, так что всё что я могу про него сказать, что "оно там есть".
В системе может быть больше одного journald, что позволяет разделить "обычную ОС" (то, что предоставляет мейнтейнер дистрибутива) и "логи важного приложения". Реализуется это через концепцию journal namespaces и шаблонов systemd (подробнее про это будет дальше).
Структура журнала
-----------------
journald может писать журналы как "per uid" (+системный), так и единый "моноблоб". Место записи содержит в себе machine id, так что если у вас machine id сбрасывается при перезагрузке, старые логи будут становиться недоступными. Структура журнала важна при ротации, потому что у journald есть общий лимит на число файлов; если это число превышено, какие-то архивы могут быть удалены раньше, чем предполагалось. Особенно это заметно при записи per uid, когда на сервер логинятся несколько пользователей. namespace'ы записываются в формате `machine_id.namespace/`.
Так как журнал содержит в себе индексы (для быстрой выборки по полям, например, за интервал времени), то места он занимает в разы больше, чем текстовая информация внутри. Первичные замеры показали величину порядка 4 (при использовании `Compress=64`) или 5.9 (без сжатия на синтетике). Спасибо [apmucm](https://habr.com/en/users/apmucm/) за указание на эту особенность journald.
RateLimit, он же "притормаживание"
----------------------------------
Это восхитительный набор опций в journald, решающий конкретные проблемы сисадминов (за счёт интересов программистов, но в этой ситуации оправдано)
journald может пропускать часть сообщений в лог, если они приходят слишком часто, причём скорость "пропуска" может быть функцией свободного места. Чем ближе к no free space available, тем больше journald пропускает логов (оттягивая неминуемое).
Опции в systemd.unit позволяют изменить эти настройки на per-unit основе (и имеют приоритет над настройками journald).
Сами опции: `RateLimitIntervalSec`, `RateLimitBurst` (который и меняется в зависимости от доступного места).
Ротация
-------
Ротация журналов - это одна из самых важных функций journald. Если на сервере не будет ротации, рано или поздно сервер перестанет нормально работать, потому что журналы в общем случае пишутся почти всегда, а место на сервере ограничено (сколько бы его не было, оно не бесконечное).
В отличие от logrotate и многих библиотек логгирования, systemd сжимает логи (в зависимости от опций) в момент записи, так что ротация - это просто переименование одного файла и начало нового, т.е. операция предельно дешёвая.
В ротации есть два важных решения: когда начинать новый журнал, и когда удалять старый архив. В процессе настройки journald разбирательство с этими параметрами было одной из самых сложных областей.
* `SystemMaxFileSize` указывает при каком размере надо начинать новый журнал.
* `MaxFileSec` указывает как долго вести основной файл журнала.
Как только эти цифры превышены (по размеру или по месту), старый файл закрывается, переименовывается, создаётся новый. (Ещё может выполняться seal, т.е. подпись файла для защиты от модификации).
Старые файлы хранятся до превышения одного из событий:
* `SystemMaxUse`- общее место, которое должно быть занято всеми журналами. Самый старый файл - кандидат на стирание, если эта величина превышена.
* `SystemKeepFree` - свободное место, которое должно оставаться на файловой системе с журналами. Если осталось меньше, чем этот объём, самые старые из архивов журналов стираются.
* `MaxRetentionSec` - максимальный возраст файлов в архиве.
* `SystemMaxFiles` - максимальное число файлов, которые сохраняются. Если число превышено, самые старые архивы удаляются.
Все лимиты применяются per namespace, т.е. если у вас три namespace'а, каждый из них определяет политику ротации самостоятельно.
SystemMaxFiles может доставить некоторое количество WTF'а, потому что если у вас `SystemMaxFileSize`, например, 128Мб, а, `SystemMaxFiles` 100, то это не гарантирует сохранение 1.2Гб логов. Файлы могут ротироваться по возрасту, а их число определяется числом разных пользователей (если включен режим per uid). Каждому из них выдадут отдельный файл журнала, плюс будут ротировать каждые `MaxFileSec`.
Log namespaces
--------------
Я считаю эту фичу кульминацией архитектуры systemd. Она получается почти бесплатно и автоматически, и является производной от шаблонов systemd, сокетов systemd и пары опций внутри.
Journald не требует себе никаких специальных привилегий и может быть запущен даже от обычного пользователя (если пользователю разрешено писать в каталог с журналами, указанный в конфиге). Он поддерживает несколько инстансов с разными конфигами, причём "инстанс" указывается очень просто - имя инстанса передаётся первым аргументом командной строки. Например, вот так:
`/lib/systemd/journald myapp`
Руками этого делать чаще всего не нужно, потому что:
1) В опциях systemd-unit'а можно указать
`[Service]
LogNamespace=myapp`
2) после чего systemd попытается писать в сокеты (устройства и т.д.) в `/run/systemd/journal.myapp.`
3) Что приведёт к активации socket-юнита `systemd-journald-varlink@myapp.socket`
4) Что (через систему зависимостей) приведёт к активации `systemd-journald@myapp.service`
5) Что приведёт к запуску `/lib/systemd/journald myap` (в виде сервиса)
6) Который прочитает файл `/etc/systemd/journald@myapp.conf` (если найдёт).
7) И пойдёт писать всё, что пишут в этот `LogNamespace`в журнал в `/var/log/journal/{{machine_id}}.myapp`
Это всё будет писаться со всеми полагающимися ротациями, дефолтными или нет настройками и т.д.
Удивительно красивая оркестрация через базовые примитивы без специальной логики под специальные случаи.
Фактически, написанного (плюс чуть-чуть `man journald.conf`) достаточно для того, чтобы начать его использовать. Остаются вопросы эргономики, эксплутации и производительности.
Багофичи
--------
Внутри systemd-journald@.service написано `LogStdout=null`. Если у вас опечатка в вашем `journald@myapp.conf`, вы об этом [не узнаете](https://github.com/systemd/systemd/issues/18951). Мы это поправили с помощью drop-in'а (оверрайда):
`/etc/systemd/system/systemd-journald@myapp.service.d/override.conf
[Service]
StandardOutput=journal`
В документации не очень внятно объяснено, как высчитывается `SystemMaxFileSize.` Вроде бы, это 1/8 от `SystemMaxUse`, который capped at 4GB. По моим рассчётам получается что-то порядка 500Мб, а на практике - 128. Исправляется явным указанием значения.
Жизнь с толстым логом
---------------------
("... та и в крынку не лезет" - анекдот)
Как только вы разрешаете вашему Важному Приложению писать Много Важных Логов у вас становится Много Важных Логов (и их архив). Это означает, что ряд порочных, но привычных техник перестаёт работать. Под запретом оказываются любые операции с journalctl, не имеющие фильтров. Т.е. никаких `journalctl|grep TRACE`, никаких `journalctl |tail` и т.д.
Свой namespace требует его указания:
`journalctl --namespace myapp --since 10:30 -u myapp_main --grep TRACE`
Compression сохраняет место, но под высокой нагрузкой утыкает journald (к счастью, отдельный процесс) в 100% одного ядра.
Безусловно, нужно отключать запись в syslog (`ForwardSyslog=no`), ради этого всё и задумывалось.
Рейтлимит может оказаться неожиданностью для программистов, которые ожидали бесконечно производительной бесконечной ленты у машины тьюринга (для записи бесконечных логов). Так как рейтлимит срабатывает по рейту, а не по важным эвентам, может оказаться, что Самая Важная Строчка не записана. Можно отключить ratelimit, но тогда Самая Важная Строчка будет уротирована забытым тредом, который непрерывно трейсится и перезапускается в течение единиц часов (даже при терабайтном месте для логов).
Послесловие
-----------
Почему не ELK? Во-первых ELK перестал быть opensource. Странная лицензия, фактически, shareware с непонятными рисками для бизнеса. Во-вторых jvm со своим волшебным миром, за которым нужно глаз да глаз (в сравнении с этим journald уже есть, отлично работает и имеет здравые дефолты). В третьих локальные логи офигенны - если у вас 400Гб логов в день, 20 серверов, то это 8Тб логов в день. 740 мегабит непрерывно, не считая всплесков. Какой там ELK-кластер надо докупить под такую штуку? А тут, на серверах, локальное место пропадает, да ещё и с готовым шардингом. Если нет задачи централизованной аналитики (а её нет), то локальные логи - это хорошо и здорово. У журналов есть индексы, а у journalctl достаточно высокая производительность (привет, С), чтобы простой `--grep` (не путать с `|grep`) работал достаточно хорошо (а часто, и значительно лучше, чем мучительное тыц-тыц в Кибане, для которой вывести 10000 записей одновременно - это DoS атака на браузер).
Производительность
------------------
(это обновление по сравнению со старым постом). В ходе эксплуатации обнаружилось, что не всё так хорошо, как ожидалось.
1. Примерная производительность journald при 100% CPU - около 30-35к сообщений в секунду. Первый попавшийся файловый логгер выдаёт примерно в 10 раз больше.
2. `AF_UNIX` в сочетании с `SOCK_DGRAM` не даёт желаемого эффекта. Подробности в `man unix`. Сообщения никогда не теряются и не переупорядочиваются, то есть это полный экивалент steam, но датаграммами. Это означает, что у вас синхронная запись в журнал, со всеми вытекающими. | https://habr.com/ru/post/546368/ | null | ru | null |
# (Микро)фронтенды и микросервисы с помощью Webpack
Привет! Меня зовут Максим, я фронтенд-разработчик компании Тинькофф, лид команды фронтендов, которые пилят международные проекты. Я работал как фронтом, так и бэкером — это дало мне релевантный опыт и в микрофронтендах в том числе.
Статья будет о фронтендах, но сначала предлагаю немного обсудить монолиты. Они бывают разные.
Зачем пилить монолит
--------------------
Когда есть команда, поддерживающая один большой продукт, и этот продукт — монолит, можно сказать, что ей повезло. Не нужно париться с микрофронтендами, хорошая разработка закрывает все вопросы. Бизнес — доволен, заказчики — довольны.
Проблемы с монолитами появляются, когда в разработке одного продукта участвуют две и больше команд. Начинаются конфликты, портятся отношения в команде.
Разберем пример. Возьмем условное приложение — любой городской портал. Там есть новости, продажа или аренда жилья и статистика по автомобилям.
Городской портал — классический монолит, SPA, который состоит из трех страниц. Каждую страницу поддерживает своя команда, каждую из этих страничек — три команды. Соответственно, тайлы у них одниВ приложении появилось несколько десятков конфликтов, образовалась очередь на релизы. Это больно и трудно.
В один прекрасный момент руководитель команды принял решение распилиться. Но помимо монолитного фронта обычно есть еще и монолитный бэк. А это значит, что будем распиливать и фронт, и бэк. Чтобы все прошло успешно, нужен план:
1. Собраться всеми командами, которые участвуют в разработке продукта.
2. Определить, что, как и зачем будем пилить.
3. Придумать схему нового решения.
4. Внести правки в новое решение.
5. Начать распил.
6. Забыть про отказоустойчивость решения.
На выходе получится примерно такая схема:
Новое решение 95 означает, что до этого было 94 варианта возможного решения, которые не подошли.
Слева — то, что было, справа — то, что получилось. Но в новой схеме есть проблема — мы не распилили UIОсновная проблема монолита — это бэк, когда много всего намешано в одной базе и бизнес-логика написана разными методами. Проблемой фронта это стало относительно недавно. Поэтому часто при распиле на микросервисы забывают фронт. Но фронт нам все равно нужно тоже распиливать, и решений, как распилить фронт, много.
Можно оставить все как есть, если текущий UI всех устраивает. Главное — соблюдать основной постулат разработки: «Работает — не трогай». Но есть минус такого решения: неудобно тащить новую функциональность, разработчики будут страдать и начнется война за место в релизе. Чтобы все разрулить, появилась новая должность — Senior Conflict Manager. Человек, который будет собирать релизы.
Если текущий UI не подходит, будем распиливать его на микрофронты.
Что такое микрофронтенд
-----------------------
Название микрофронтенд появилось в 2016—2017 годах. Это некий постулат идей о том, как должно выглядеть приложение. Идей около 17, [и на сайте Micro-Frontends.org](https://micro-frontends.org/) они все расписаны.
Я выделил три важных аспекта микрофронта.
**Изолированный код каждой команды.** Не должно быть переплетений. Как этого добиться — вопрос двоякий. Можно уехать в другие репозитории, можно в разные NPM-скопы и прочее.
**Уникальный префикс для каждой команды.** Не должно быть пересечений, тогда не будет пересечений в коде.
**Выбор нативного API, который предоставляет фреймворк.** Это могут быть нативные фишки браузера, нативные фишки фреймворка, и не нужно писать свои костыли. Если что-то не нравится, можно заявить в issue на GitHub в этот фреймворк либо попробовать закатить пул-реквест.
Я убедился опытным путем, что не стоит придумывать свои решения. Когда я придумывал свои решения, мне казалось, что они классные и отлично работают. Но мои фронтендеры потом в конце рабочего дня плакали.
Какие есть варианты распила
---------------------------
**Распил в NPM-библиотеке.** У каждой команды будет своя страничка, все с отдельными тегами и хранятся в разных местах — определен свой NPM-скоуп, и код можно разнести. Понадобится приложение-синхронизатор, которое возьмет код всех команд и подключит к себе.
Микросервис все же не об этом. Он о том, что два приложения могут вместе работать и взаимодействовать между собой. А что, если сделать три приложения?
Источник: https://martinfowler.com/articles/micro-frontends.html
Три приложения с базовыми пайплайнами. Каждое приложение собирается отдельно, гоняем на каждом тесты и деплоим. Процесс компоновки всего воедино уже не такой подробный: у одних это будет компоновка через Iframe, у других свои фреймворки и велосипеды или же гитовые сабмодули и сборка в единый бандл. Целостного решения нет**Использование монорепозиториев.** Когда есть один репозиторий и создается несколько приложений, все они хранятся в своих отдельных папках и получаются локальные библиотеки. Как NPN-библиотека, только не в NPN, а локально в коде, и при сборке попадет в зависимость от каждого из приложений.
Нужно сделать библиотеку с хедером и завести три приложения. Каждая команда реализует свой блок логики, у них есть общий хедер, через который осуществляется навигация.
На выходе получается вроде бы монорепозиторий. Но нужен SPA. Решение нашлось в 2018 году, когда появился пятый Webpack. Помимо всяких ускорений работы он принес с собой Modul Federation.
Модуль имеет простую концепцию — притягивать через динамический импорт целое приложение. Будет условное приложение-хост, в котором описан загрузчик и указаны дочерние приложения для загрузки в основное.
```
plugins: [
new ModuleFederationPlugin({
remotes: {
main: 'main@http://localhost:4201/remoteEntry.js',
rent: 'rent@http://localhost:4202/remoteEntry.js',
cars: 'cars@http://localhost:4203/remoteEntry.js',
},
shared: share({
'@angular/core': {singleton: true, strictVersion: true, requiredVersion: 'auto'},
'@angular/common': {singleton: true, strictVersion: true, requiredVersion: 'auto'},
'@angular/common/http': {singleton: true, strictVersion: true, requiredVersion: 'auto'},
'@angular/router': {singleton: true, strictVersion: true, requiredVersion: 'auto'},
'@angular/forms': {singleton: true, strictVersion: true, requiredVersion: 'auto'},
...sharedMappings.getDescriptors(),
}),
}),
sharedMappings.getPlugin(),
],
```
Есть два приложения, в рамках MFE это называется Host и Remote. У host-приложения есть webpack-конфиг с плагином MFE, он принимает в себя список зависимых приложений и библиотеки, которые должны быть едиными для всех приложений.
Подробнее про Remotes
---------------------
Блок Remotes — это webpack-конфиг хост-приложения, приложения-синхронизатора. В этом блоке определяются названия проектов, они уникальны и должны иметь свой префикс.
Указывается URL-адрес, откуда забирать. Shared-секция описывает, какие зависимости в package.json должны иметь строгую версию и должна ли эта зависимость являться single-тоном.
1 — название приложения, в которое надо загрузить; 2 — URL-адрес, откуда нужно загрузить; 3 — файл, который надо загрузить
Блок Remotes позволяет разнести свои приложения по разным доменам. В плане при распиле монолита был пункт «забыть про отказоустойчивость». Про нее забывают всегда.
Такое нововведение, которое позволяет с хоста загружать свой файл, дает развернуть приложение на отдельном железе или отдельном деплойменте в кубе. Чтобы все приложения стали независимыми и имели разное количество памяти, ЦПУ.
Если кому-то надо больше — накидываем больше. Например, пять разных приложений — пять разных деплойментов, но будет выглядеть как SPA.
В Angular есть файлик app.module.ts, там описаны компоненты, модули, зависимости приложения, декларируется роутинг и многое другое. В рамках remote-приложения на MFE сохраняется app.module.ts remote, но появляется новый файлик — remote-entry.module.ts. В нем описываются зависимости приложения, которые нужны в remote-режиме.
Получается две схемы деплоя: можно загрузиться как независимое приложение, стоящее на отдельном хосте, и зависимое приложение через RemoteEntryComponent.
Но есть нюанс. Если в app-модуле нужно объявить root-зависимости, то во втором случае нужно определить child-зависимость. Они должны быть дочерними, потому что root-зависимости будут описаны в app-модуле нашего хост-приложения.
```
plugins: [
new ModuleFederationPlugin({
name: "main",
fileName: "remoteEntry.js",
exposes : {
'./Module': 'apps/main/src/app/remote-entry/entry.module.ts'
},
shared: share({
'@angular/core': {singleton: true, strictVersion: true, requiredVersion: 'auto'},
'@angular/common': {singleton: true, strictVersion: true, requiredVersion: 'auto'},
'@angular/common/http': {singleton: true, strictVersion: true, requiredVersion: 'auto'},
'@angular/router': {singleton: true, strictVersion: true, requiredVersion: 'auto'},
'@angular/forms': {singleton: true, strictVersion: true, requiredVersion: 'auto'},
...sharedMappings.getDescriptors(),
}),
}),
sharedMappings.getPlugin(),
],
```
Внутри webpack.config.js добавляем плагин MFE, в котором описаны базовые импорты, правила и многое другое.
Появилась секция name, где нужно указать название дочернего приложения, которое мы разрабатываем. А в секции exposes указываем ссылку на тот модуль, который будет упаковываться в файл remoteEntry.js.
Аналогично описывается shared-секция тех зависимостей, что должны быть синхронизированы. Мы синхронизируем Angular, можем синхронизировать любую библиотеку из NPM-скоупа и любую локальную библиотеку, если используем там монорепозиторий.
Подробнее про Host
------------------
Все описывается в app-модуле. Я декларирую, определяю рутовый роутинг, который будет базовым для всего и главным, определяю несколько путей, импортирую к себе лейзи-модуль. Этот модуль должен быть загружен не сразу, при старте приложения, а когда мы перейдем на условный путь. Для этого делаем ссылку на динамический модуль дочернего приложения.
```
@NgModule({
declarations: [AppComponent],
imports: [
BrowserModule,
RouterModule.forRoot([
{
path: 'main',
loadChildren: () => import('main/Module').then(m => m.RemoteEntryModule)
},
{
path: 'rent',
loadChildren: () => import('rent/Module').then(m => m.RemoteEntryModule)
},
{
path: 'cars',
loadChildren: () => import('cars/Module').then(m => m.RemoteEntryModule)
}
])
],
bootstrap: [AppComponent]
})
export class AppModule {}
```
Все, можно считаться микрофронтендером!
Дальше я напишу примерно такой UI, в котором будет хедер, а внутри хедера — ссылки, ведущие нас по приложению.
```
### My city portal
Main
Rent
Cars
```
Ангулярщики уже понимают, роутер-аутлет — секция, куда будет вставляться контент зависимого приложения. Есть роутинг — мы определили его верхнюю часть, и роутер-аутлет — блок, в котором будет находиться дочерний роутинг.
Дальше начинается магия — происходит анимация. Я хожу по нашему приложению, при нажатии на LoginPage у меня загружается файлик, который загружает в приложение LoginPage, при нажатии на Origination загружается приложение Origination. В приложении Origination есть кнопка Go To Lazy — это дочерний роутинг зависимого приложения. Ничего не перезагружается, все работает как классическое SPA, то есть фактически монолит, но им не является.
Так выглядит код в консолиMainJS попадает к нам с загрузкой приложения. Появляется динамический импорт, который берет из конфига указанный URL и идет на хост за нужным файликом. Потом начинается процесс загрузки того приложения внутри нашего.
В браузере получаем remoteEntry.js, который начинает тащить те зависимости, что нужны ему для приложения. И если зайти на localhost.42, должно открыться приложение с уже описанным там роутингомПятый выход Webpack дал нам очень много фишек, направленных на ускорение сборок, улучшение минификации и улучшенную работу с плагинами. И как дополнение — гибкая система управления микрофронтами, которая работает, и дополнительно ничего больше не нужно.
Работа из коробки с нативом и голым Webpack — там уже есть pluginFederation и можно делать микрофронты. Все популярные фреймворки имеют в комплекте MFE.
Выводы
------
Микрофронты позволяют решить проблему конфликтов приложений. В нашем примере с точки зрения пользователя мы создали монолит — один раз зашел и все сделал, а на деле все на микрофронтах.
Webpack выпуском MFE понизил планку входа в микрофронты. Если раньше нужно было писать загрузчик, понимать, как все работает на деле, то теперь все стало проще — плагин, документация к нему. Идешь по документации и делаешь, как там написано.
Получается довольно гибкая работа с надежностью. Если в одном из условных пяти приложений команда что-то сломала, то есть health-чеки, проверяющие доступность приложений, и если приложение недоступно — вешают плашку. Можно с каждым приложением работать отдельно.
А в следующей статье расскажу, как мы съезжали на Modul Federation. Если есть вопросы — жду в комментариях. | https://habr.com/ru/post/701152/ | null | ru | null |
# Использование типов TypeScript вместо Swagger
Сегодня я расскажу о том, как мы можем с помощью типов написать простое расширение для ExpressJS.
А если вы в своём приложении/приложениях используете только решения на TypeScript(JavaScript), то у вас отпадёт необходимость в Swagger.
Вообще, одно из главных преимуществ разработки серверного кода на NodeJS — это один язык программирования с Web-интерфейсом/React/Vue Native. Это даёт возможность написать общий код в одном месте только один раз и использовать его затем везде.
Именно это мы сейчас с вами и попытаемся сделать.
Представим простой монорепозиторий, который состоит из двух проектов:
* **server**: Backend WebAPI, написанный на ExpressJS;
* **client**: Frontend SPA-клиент, написанный на VanillaJS.
Приложение крайне простое - todo, которое должно уметь создавать, получать и удалять задания. Как обычно поступают в таких условиях? Пишут backend сервер, в лучшем случае подключают к нему swagger (что приводит к существенным изменениям в коде), или ведут Google Table со списком контрактов. В худшем - вам придётся каждый раз смотреть исходный код сервера, и подгонять под него свой код.
Объявляем общие типы
--------------------
Для начала создадим другую папку в нашем монорепозитории и назовём её **shared**. Сделаем его npm проектом на typescript, выполнив в корне папке команды:
```
npm init
npm install typescript --save-dev
```
Для имени этого проекта я буду использовать имя монорепозитория и название папки:
```
// shared/package.json
{
name: @express-ts-react/shared,
...
}
```
> **Несколько замечаний об этом проекте**
>
> Поскольку подразумевается, что код в этом проекте будет использоваться в разных службах и приложениях, то необходимо соблюдать следующие правила:
>
> - Не устанавливать специфичные фреймворки и библиотеки;
>
> - Желательно вообще ничего не устанавливать :)
>
> - Старайтесь писать здесь максимально абстрактный код, или код, который будет работать везде.
>
> - Каждое приложение или сервер, если предоставляет какие-то контракты для работы с ним, должно иметь собственную папку, и оно не должно ниоткуда, кроме **common** импортировать код.
>
>
Теперь создадим папку **common** в проекте *@express-ts-react/shared* и объявим её локальным модулем:
```
// shared/common/package.json
{
"sideEffects": false,
"main": "./index.js"
}
```
Там же создадим файл, в котором мы объявим самые важные генерики, которых уже будет достаточно, чтобы заменить нам swagger. `EndpointMeta` — это тип, который описывает один endpoint. По сути, любой метод нашего RestApi задаётся таким набором. `T` и `U` здесь использованы не просто так, они понадобятся для автоматического и динамического формирования интерфейсов наших контроллеров. Пока вам нужно знать, что `T` —это параметры аргументов, которые принимает метод контроллера, а `U` — это формат ответа.
```
// shared/common/index.tsx
/**
* REST description about endpoint
* Can be extended with additional fields or methods. For instance, auth protected endpoint
*/
export type EndpointMeta = {
/\*\*
\* helper for type in runtime definition
\*/
\_: "endpointMeta";
/\*\*
\* Endpoint route
\*/
route: `/${string}` | `\*`;
/\*\*
\* Url in express format without route prefix
\*/
url: `/${string}` | `\*`;
/\*\*
\* Method in express format, can be extended by others
\*/
method?: "get" | "post" | "put" | "delete";
};
/\*\*
\* Get argument types of endpoint method
\*/
export type GetInnerArgsOfMeta~~= S extends EndpointMeta
? T
: never;
/\*\*
\* Get Response type of endpoint method
\*/
export type GetInnerResponseOfMeta~~= S extends EndpointMeta
? S
: never;
/\*\*
\* Get endpoint type, where key is the endpoint name,
\* args - is the endpoint method arguments
\* and result is endpoint response
\*/
export type EndpointsProvider = {
[key in keyof T]: (
args: GetInnerArgsOfMeta
) => GetInnerResponseOfMeta;
};~~~~
```
А теперь используя только эти четыре типа вы можете легко создавать интерфейсы/контракты для ваших контроллеров, и использовать этот код как на сервере, так и на клиенте. Снизу, например, представлены методы для нашего ToDo приложения:
```
// shared/server/index.tsx
import { EndpointMeta, EndpointsProvider } from "../shared";
const getTasks: EndpointMeta<
{
query?: {
status?: boolean;
ids?: string[];
};
},
Promise
> = {
\_: "endpointMeta",
url: "/",
method: "get",
};
const getTaskById: EndpointMeta<
{
params: {
id: string;
};
},
Promise
> = {
\_: "endpointMeta",
url: "/:id",
method: "get",
};
const addTask: EndpointMeta<{ body: Task }, Promise> = {
\_: "endpointMeta",
url: "/:id",
method: "post",
};
const deleteTaskById: EndpointMeta<
{
params: {
id: string;
};
},
Promise
> = {
\_: "endpointMeta",
url: "/:id",
method: "delete",
};
// Our final endpoints collection
const endpoints = {
getTasks,
getTaskById,
addTask,
deleteTaskById,
};
```
Четыре переменные, по сути, содержат всю необходимую информацию, которую нужно, чтобы:
* Создать ExpressJs роутинг;
* Без подглядывания в сторонние данные написать клиент для этого сервера.
Почему я уверен, что не придётся подглядывать? Давайте создадим простой класс, который можно использовать везде, независимо от среды исполнения и объявим его, как реализующим этот непонятный тип `EndpointsProvider`:
```
// shard/server/index.tsx
class TaskController implements EndpointsProvider {}
```
Если мы оставим класс как есть, то, во-первых, на нас будет ругаться vscode, а во-вторых, при попытки собрать проект командой `npx tsc` мы увидим ошибку:
```
blog/index.ts:77:7 - error TS2420: Class 'TaskController' incorrectly implements interface 'EndpointsProvider<{ getTasks: EndpointMeta<{ query?: { status?: boolean | undefined; ids?: string[] | undefined; } | undefined; }, Task[]>; getTaskById: EndpointMeta<{ params: { id: string; }; }, Task>; addTask: EndpointMeta<...>; deleteTaskById: EndpointMeta<...>; }>'.
Type 'TaskController' is missing the following properties from type 'EndpointsProvider<{ getTasks: EndpointMeta<{ query?: { status?: boolean | undefined; ids?: string[] | undefined; } | undefined; }, Task[]>; getTaskById: EndpointMeta<{ params: { id: string; }; }, Task>; addTask: EndpointMeta<...>; deleteTaskById: EndpointMeta<...>; }>': getTasks, getTaskById, addTask, deleteTaskById
77 class TaskController implements EndpointsProvider {}
Found 1 error.
```
Эта ошибка говорит, что наш класс `TaskController` неправильно реализует `EndpointsProvider`: отсутствуют функции `addTask`, `getTaskById`, `getTasks`, `deleteTask`. Давайте теперь попробуем реализовать эти методы.
```
// shared/server/index.tsx
...
class TaskController implements EndpointsProvider {
getTaskById: (args: {
params: {
id: string;
};
}) => Task = (args) => {
return {
id: "",
description: "",
done: true,
};
};
getTasks: (args: {
query?: {
status?: boolean;
ids?: string[];
};
}) => Task[] = (args) => {
return [{
id: "",
description: "",
done: true,
}];
};
addTask: (args: { body: Task }) => Task = (args) => {
return args.body;
};
deleteTaskById: (args: {
params: {
id: string;
};
}) => Task = (args) => {
return {
id: "",
description: "",
done: true,
};
};
}
```
Теперь команда `npx tsx` ничего не пишет нам, а значит, всё работает! Как видно, это класс для контроллера, и в нём уже содержится информация о конкретной реализации методов, поэтому по-хорошему этот класс нужно уже выносить в проект нашего сервера. Чтобы сделать клиент, нужно унаследовать точно такой же интерфейс, но уже вместо конкретной реализации, нужно заменять `url` на параметры и формировать fetch запрос на сервер.
В следующей части я покажу, как можно автоматизировать на основе `const endpoints` формирование сервера и класса клиента. А также мы создадим базовый контроллер, запрос и ответ, сделаем их расширяемыми собственными свойствами и спасём себе жизнь от ошибок и сохраним часы и дни для синхронизации работы серверов и клиентов.
При использовании TypeScript код заметно увеличивается в размере, и кому-то это может казаться некрасивым. Но когда вы работаете в современной IDE или текстовом редакторе на стероидах (VSCode) - то вы оцените, насколько силён TypeScript. Его использование существенно снижает количество ошибок, а также доступность для понимания кода для вас и членов вашей команды. | https://habr.com/ru/post/571240/ | null | ru | null |
# Упрощенный синтаксис для jsonb в PostgreSQL 14
Как сообщает telegram-канал [Cross Join](https://t.me/crossjoin), в репозиторий Postgres упал [комит](https://github.com/postgres/postgres/commit/676887a3b0b8e3c0348ac3f82ab0d16e9a24bd43), упрощающий работу с jsonb. Теперь можно обращаться к частям jsonb с помощью квадратных скобок, причем это работает как на чтение, так и на запись.
Прощай jsonb\_set и прочие костыли типа `data = data - 'a' || '{"a":5}'`
Несколько примеров:
-------------------
Обновляем значение объекта по ключу. 25 здесь является числом, но взято в кавычки, потому что присваиваемое значение должно быть jsonb
```
-- (person_data имеет тип jsonb)
UPDATE users
SET person_data['age'] = '25';
```
Обновление работает и с пустыми (null) jsonb.
Фильтруем таблицу по полю name=Pasha. Pasha — строка, но тоже записана в форме jsonb: '"Pasha"', поэтому лишние двойные кавычки
```
SELECT *
FROM users
WHERE person_data['name'] = '"Pasha"';
```
Получаем значение объекта по ключу "age"
```
SELECT ('{"age": 25}'::jsonb)['age'];
```
Или можно указать длинный путь
```
SELECT ('{"a": {"b": {"c": 1}}}'::jsonb)['a']['b']['c'];
```
Элемент массива по индексу
```
SELECT ('[1, "2", null]'::jsonb)[1];
```
Ну и самое главное: изменения войдут в postgreSQL 14!
Оригинальная идея синтаксиса принадлежит Олегу Бартунову, реализация — Дмитрий Долгов | https://habr.com/ru/post/540428/ | null | ru | null |
# HTML-минимизация в Web Essentials 2013
Одним из наиболее существенных нововведений для веб-разработчиков в Visual Studio 2013 стал новый HTML-редактор. В отличие от старого редактора, который представлял из себя смесь из управляемого и неуправляемого кода (и даже использовал некоторые компоненты FrontPage), новый редактор был полностью переписан на управляемом коде (в качестве основы использовался HTML-редактор из WebMatrix).
> Стоит отметить, что для ASP.NET Web Forms (файлы с расширениями `.aspx`, `.ascx` и `.master`) по-прежнему используется старый редактор.
Помимо улучшенных средств для работы с HTML-кодом, в новом редакторе также реализована поддержка синтаксиса представлений [KnockoutJS](http://knockoutjs.com/), [AngularJS](http://angularjs.org/) и [Handlebars](http://handlebarsjs.com/), и IntelliSense для специальных префиксов и META-тегов (Facebook, Twitter, Open Graph, Windows Phone, iOS и др.).
К сожалению, не каждая новинка из мира веб-разработки может попасть в Visual Studio в силу следующих причин:
1. Многие современные веб-технологии и библиотеки являются Open Source-проектами (например, компиляторы [LESS](http://lesscss.org/) и [CoffeeScript](http://coffeescript.org/), верификатор [JSHint](http://www.jshint.com/) и т.д.), и некоторые из этих проектов имеют лицензии, которые не позволяют включать их в состав коммерческих продуктов.
2. Сейчас веб-технологии развиваются настолько быстро, что их поддержка средствами разработки может стать неактуальной в течение одной недели. Поэтому ни частые релизы Visual Studio (сейчас период между релизами сократился с двух лет до одного года), ни периодические обновления не позволяют поддерживать Visual Studio в полностью актуальном состоянии.
Для того, чтобы решить перечисленные выше проблемы сотрудником компании Microsoft Мэдсом Кристенсеном было создано VS-расширение [Web Essentials](http://vswebessentials.com/). Исходный код Web Essentials опубликован на GitHub (доступны 2 версии: [2012](http://github.com/madskristensen/WebEssentials2012) и [2013](http://github.com/madskristensen/WebEssentials2013)).
Ниже перечислены дополнительные возможности HTML-редактора из Visual Studio 2013, которые становятся доступными после установки Web Essentials 2013:
1. Поддержка [Zen Coding](http://code.google.com/p/zen-coding/) (более подробную информацию об использовании Zen Coding в Web Essentials можно прочитать в статье Джона Папа [«Zen Coding in Visual Studio 2012»](http://www.johnpapa.net/zen-coding-in-visual-studio-2012/)) и генератор текста-«рыбы» [Lorem Ipsum](http://ru.wikipedia.org/wiki/Lorem_ipsum) (например, если ввести `lorem10` и нажать клавишу **TAB**, то в код будут вставлены 10 слов из трактата Цицерона «О пределах добра и зла»).
2. Команда **Go To Definition** для тегов , | https://habr.com/ru/post/199206/ | null | ru | null |
# Правда ли, что Go быстрее Ruby?
Последние несколько лет я занимаюсь созданием игр для социальных сетей. В качестве back-end применяю связку Ruby + Sinatra + Redis. Redis используется в качестве единственной базы данных. Производительности одной базы Redis часто не хватает, поэтому используется кластер из нескольких баз данных. Более подробно о том, как создавалось решение в виде кластера баз Redis можно прочитать в [этой статье](http://habrahabr.ru/post/214131/).
В последнее время у меня большой интерес вызывает язык программирования Go — слишком много плюшек его использование сулит программисту. Хочется back-end для новых игр написать на нем, но существующая и отлаженная кодовая база на Ruby мешает этому.
Поэтому я решил двигаться небольшими итерациями и начал с переписывания микросервисов применяемых в играх на Go.
Во всех микросервисах есть подключение к базам Redis. Обычно используется 8 баз Redis, где игра хранит данные.
Строка с частью запроса к Redis преобразуется с помощью SHA-1 в шестнадцатеричное число. Затем находится остаток от деления этого числа на 8. И в зависимости от него данные записываются/читаются из нужной базы.
Исходный вариант на ruby, который я решил переписать на Go.
```
def node0(text)
return Integer('0x'+Digest::SHA1.hexdigest(text))%8
end
```
К сожалению или к счастью такой подход в лоб на Go не сработал. Получаемая 16-ричная строка представляла слишком большое число. В тип int64 это число не помещалось.
Как решить проблему?
У нас 8 баз и 16-ричное число, от которого надо взять остаток от деления на 8.
Ответ.
**Первое, что приходит на ум.** Нам достаточно знать последний символ 16-ричного числа, чтобы посчитать остаток от деления всего числа на 8.
Мы легко можем переписать решение на ruby с учетом вышесказанного так:
```
def node1(text)
s = Digest::SHA1.hexdigest(text)
return Integer('0x'+s[s.size-1, 1]) % 8
end
```
То же самое, но на Go:
```
func node1 (text string) int64 {
h := sha1.New()
h.Write([]byte(text))
sha1_hash := hex.EncodeToString(h.Sum(nil))
sha1_hash_len := len(sha1_hash)
last := sha1_hash[sha1_hash_len-1:sha1_hash_len]
value, _ := strconv.ParseInt(last, 16, 64) //int64
return value % 8
}
```
**Второе, что удачно оказалось**
В процессе написания кода, представленного выше, выяснилось, что Go в ходе выполнения SHA-1 представляет число в виде набора десятичных чисел, а потом уже их приводит к 16-ричному виду. Поскольку нам нужен остаток от деления, то мы можем просто взять последнее десятичное число вместо 16-ричного последнего символа и сэкономить на преобразованиях из одной системы счисления в другую.
```
func node2 (text string) int64 {
h := sha1.New()
h.Write([]byte(text))
mas := h.Sum(nil) // "hello world" -> [42 174 108 53 201 79 207 180 21 219 233 95 64 139 156 233 30 232 70 237]
return int64(mas[len(mas)-1]) % 8 // Берем последний элемент массива. Это целое десятичное число. И считаем остаток от деления на 8
}
```
Этот финт позволил еще быстрее вычислять то, что необходимо. Но на Ruby такой трюк выполнить не удалось. Поэтому корректнее сравнивать производительность node1 из Ruby и node1 из Go.
**И так какая скорость работы у всего представленного?**
Как я решил протестировать:
Посчитать, в какую базу данных положить данные, относящиеся к каждому из миллиона пользователей.
На Ruby:
```
for i in 1..1000000 do
node1("user:"+i.to_s)
end
```
и на Go:
```
for i := 1; i <= 1000000; i++ {
node1("user:"+string(i))
}
```
Полный код можно посмотреть на [github](https://github.com/dfer/rubyvsgo).
Для чистоты эксперимента я запускал каждый скрипт по 10 раз, и ниже представлены средние значения.
Код запускался на версиях Ruby 1.8.7 и 2.1.3. Версия Go была 1.4.2
Значения в секундах. Меньше — лучше.
Ruby 1.8.7
node0 — 22.32
node1 — 17.24
node11 — 16.81
Ruby 2.1.3
node0 — 15.46
node1 — 11.15
node11 — 11.05
Go 1.4.2
node1 — 6.15
node2 — 4.36
**Почему такие старые версии Ruby?**
Код многих проектов я начал создавать 4-5 лет назад. По мере возможности я переносил его на новые версии Ruby. В частности на 2.1.3. Согласен, что на последней версии Ruby 2.2.2 результаты могут быть лучше, но явно не в два раза.
**Выводы**
* 1. Go 1.4.2 быстрее старых версий Ruby в 3 раза. И быстрее современных версий в 2 раза.
* 2. Ruby неплохо оптимизировали с версии 1.8.7 до 2.1.3. Прирост скорости на 25-30%.
* 3. Ruby, ты был верным другом и соратником, мы многое прошли вместе, но… я встретил Go. Теперь мне с ним по пути. | https://habr.com/ru/post/260033/ | null | ru | null |
# Программный поиск общего кода с помощью oEmbed
Всем доброго времени суток! Хочу поделиться переводом статьи ""[Programmatically Discovering Sharing Code With oEmbed](https://www.smashingmagazine.com/2019/11/programmatically-discovering-sharing-code-oembed/)" автора Drew McLellan.
Введение
--------
*На многих сайтах размещены мультимедиа и контент, которыми можно поделиться в другой платформе с помощью некоторого HTML-кода для встраивания. Что произойдет, если у вас есть только URL-адрес элемента и вам нужно найти встраиваемую версию мультимедиа без участия человека? Вот тут нам и пригодится oEmbed.*
**Сеть полна сервисов, которые содержат разнообразный контент**, такой как видео, изображения, музыка и подкасты, карты и графики, а также всевозможные развлечения. Скорее всего, когда вы добавите свой контент на сайт, он предложит вам способ внедрить этот контент в веб-страницу где-нибудь ещё.
На таких сайтах, как YouTube, есть собственный встраиваемый проигрыватель, который популярно использовать в постах блога и даже на страницах продуктов. Soundcloud имеет код для встраивания их музыкального проигрывателя на сайт вашей группы. Благотворительные сборщики денег могут загрузить маршрут своей большой гонки на сайт, подобный Strava, и захотеть поделиться им на своем сайте по сбору средств, чтобы показать их спонсорам.
Все это можно сделать, найдя опцию « Поделиться» на хостинг-сайте и скопировав некоторый код, который обычно представляет собой смесь HTML и JavaScript. Затем этот код обычно может быть вставлен на целевую страницу, и хостинг-сайт предоставит богатое представление контента для просмотра всем вашим друзьям, клиентам и контактам.
Пока все хорошо, и это достаточно хорошо подходит для встраивания контента вручную. Тем не менее, есть другой вариант использования, где результат один и тот же, но путь к нему совершенно другой.
Программный обмен
------------------
Давайте представим, что вы создаете приложение или сайт, который принимает контент от пользователя. Это может быть что-то простое, например, базовая интернет-страница для сотрудников, чтобы делиться новостями с коллегами, или что-то огромное, например, целая социальная сеть, где люди могут зарегистрироваться и начать публиковать сообщения.
В обоих случаях вам нужно решить, что делать, если пользователь добавляет URL-адрес как часть этого содержимого. Вы можете представить себе сценарий:
> Check out this video! [youtu.be/jw7bRnFbwAI](https://youtu.be/jw7bRnFbwAI)
На данный момент, как издательская система, вам нужно выяснить, что делать. Первый вариант — ничего не делать и просто оставить URL-адрес в виде обычного текста. Это не очень хорошая, поскольку пользователи обычно хотят щелкнуть URL-адрес, а простой текст не поможет им перейти на страницу на другом конце.
Второй вариант — превратить его в ссылку. Это хороший выбор, так как пользователи могут перейти по ссылке и получить доступ к контенту. Но при этом они покидают ваш сайт и могут не вернуться.
Наилучшим пользовательским опытом может быть возможность извлекать проигрыватель для этого контента и вставлять его прямо туда, а не только в URL. Это позволило бы пользователям просматривать содержимое прямо на вашем сайте, как, например, на Facebook.
Это создает проблему. Учитывая URL, как я смогу превратить это в код для встраивания HTML / JavaScript, необходимый для показа большинству пользователей на странице?
Если это такой известный сайт, как YouTube, я мог бы написать некоторый код, который использует API YouTube для извлечения видеоинформации и получения или создания кода для встраивания таким образом. Я мог бы сделать то же самое для других видео сервисов, таких как Vimeo и VIVO. Я могу написать код для распознавания URL-адресов Flickr и Instagram и использовать их API-интерфейсы для получения хороших встраиваемых версий фотографий. И то же самое для Твиттера и твитов. Но на это уйдет очень много сил и времени!
В идеале, нужен стандартизированный способ передачи URL-адреса части содержимого в блок кода для встраивания, чтобы отобразить это содержимое на странице. Если вы обратили внимание, вы поймете, что для этого подходит oEmbed.
Происхождение OEmbed
--------------------
Это была именно та проблема, с которой [Лия Калвер](http://leahculver.com/) столкнулась, работая над Pownce (действительно инновационным сайтом социальных сетей, который был Betamax для VHS в Twitter). Pownce хотел встроить богатые представления контента в поток обновлений пользователя, но не хотел ограничивать поддержку только теми службами, с которыми они специально писали код для интеграции. На ужине с коллегой Майком Мэлоуном, а также с [Кэлом Хендерсоном](https://www.iamcal.com/) (который возглавлял инжиниринг в Flickr — одном из крупнейших поставщиков такого контента в то время) и [Ричарде Кроули](https://rcrowley.org/) они вместе выработали идею открытого стандарта для получения кода для встраивания. URL. Хендерсон ушел и разработал что-то на основе обсуждения, так и родился oEmbed.
Использование OEmbed
--------------------
Вот как это работает.
Он начинается с URL-адреса, который указывает на один элемент содержимого. Это может быть видео на YouTube, изображение или что-то еще. Обычно это будет предоставляться пользователем вашего сайта или приложения как часть некоторого контента, который он хочет опубликовать. Первым шагом является получение содержимого страницы по этому URL, который должен быть HTML-страницей.
Если сайт, на котором размещен контент, поддерживает oEmbed, в разделе этой страницы должен быть link элемент с oembed типом контента:
**Примечание по XML**: oEmbed поддерживает ответы как в формате XML, так и в формате JSON. В этой статье я рассматриваю только JSON, потому что мы не дикари. Но если вам необходимо работать с XML, имейте в виду, что он поддерживается со спецификацией oEmbed, хотя вы можете обнаружить, что некоторые провайдеры предлагают только ответы JSON.
Этот тег ссылки в качестве rel атрибута установлен на alternate и type установлен либо либо, application/json+oembedлибо text/xml+oembed. Именно этот атрибут подсказывает нам тот факт, что указанный в URL-адресе на href самом деле является конечной точкой API oEmbed для получения сведений о содержимом.
Этот URL обычно имеет два параметра: url и format.
*Общие параметры URL для начального запроса потребителя*
[Полная спецификация](https://oembed.com/) идет в гораздо более подробно здесь (и вы должны ссылаться, что если создать свою собственную реализацию), но эти два параметра, вы, вероятно, увидеть больше всего.
Итак, у нас есть URL, выбрали страницу, нашли тег ссылки oEmbed с другим URL для конечной точки API. Затем мы запрашиваем этот новый URL, и он возвращает всю информацию, которую служба должна предоставить об этом фрагменте контента.
```
{
"author_name": "Smashing Magazine",
"width": 480,
"title": "Smashing TV: Inclusive Components with Heydon Pickering (Nov 7th 2019)",
"provider_name": "YouTube",
"height": 270,
"html": "",
"provider_url": "https://www.youtube.com/",
"thumbnail_url": "https://i.ytimg.com/vi/jw7bRnFbwAI/hqdefault.jpg",
"type": "video",
"thumbnail_height": 360,
"author_url": "https://www.youtube.com/channel/UCSDtqcJ8ZXviPrEcj1vuLiQ",
"version": "1.0",
"thumbnail_width": 480
}
```
А теперь мы пообщаемся! Ответ дает нам много информации о контенте. В version обозримом будущем должно быть 1.0, что является текущей версией спецификации oEmbed. Другая возвращаемая информация во многом зависит от стоимости type.
Типы Ответов
------------
Значение type ключа в ответе указывает, какой тип носителя вы собираетесь встраивать.
Помимо выделенного видеоконтента, наиболее распространенным типом, который вы можете увидеть в дикой природе, является rich. Даже сам Flickr, все еще отправляя photo ответ, также предоставляет html крутой встраиваемый «проигрыватель» для изображения.
В большинстве случаев встраивание контента на ваш сайт — это всего лишь случай использования кода, предоставленного в качестве html значения.
Примечание О Безопасности
-------------------------
Вы должны быть осторожны с одной вещью: если брать ответ HTML и программно внедрять его в страницу, которую вы размещаете, без человека, который дважды проверяет код, который вы вставляете, всегда существует вероятность того, что этот код будет вредоносным. Таким образом, вы должны принять соответствующие меры для снижения риска.
Это может включать в себя фильтрацию URL-адресов, чтобы убедиться, что схемы и домены соответствуют ожидаемым, и песочницу кода в iframe в другом домене без файлов cookie. Вы должны получить доступ к ситуации, в которой вы используете код, и убедиться, что вы не подвергаете себя чрезмерному риску.
Начнём
------
Не менее важно понимать процесс при использовании oEmbed, но реальность такова, что в большинстве распространенных языков есть библиотеки, которые абстрагируют процесс и делают его относительно простым.
Например, НПМ упаковывание oembed обеспечивает очень простой интерфейс для создания запроса на основе URL контента и получение ответа обратно oEmbed.
Сначала установите пакет в свой проект:
```
npm i oembed
```
А затем запросите URL. Здесь я использую URL-адрес презентации в Notist.
```
const oembed = require('oembed');
const url = 'https://noti.st/drewm/ZOFFfI';
oembed.fetch(url, { maxwidth: 1920 }, function(error, result) {
if (error)
console.error(error);
else
console.log("oEmbed result", result);
});
```
И ответ:
```
{
type: 'rich',
version: '1.0',
title: 'Understanding oEmbed',
author_name: 'Drew McLellan',
author_url: 'https://noti.st/drewm',
provider_name: 'Notist',
provider_url: 'https://noti.st',
cache_age: 604800,
thumbnail_url: 'https://on.notist.cloud/slides/deck4179/large-0.png',
thumbnail_width: 1600,
thumbnail_height: 900,
html:
'View [Understanding oEmbed](https://noti.st/drewm/ZOFFfI) on Notist.
',
width: 960,
height: 540
}
```
Если вы хотите сделать то же самое в PHP, удобный пакет с именем [embed / embed](https://packagist.org/packages/embed/embed) доступен для установки через Composer.
```
composer require embed/embed
```
И тогда в вашем проекте PHP:
```
use Embed\Embed;
$info = Embed::create('https://noti.st/drewm/ZOFFfI');
$info->title; // "Understanding oEmbed"
$info->authorName; // "Drew McLellan
$info->code; // " ... "
```
Как вы можете видеть, с использованием библиотеки процесс становится очень простым, и вы можете быстро перейти от URL-адреса к встраиваемому коду, готового показать богатое представление контента пользователя.
Вывод
-----
oEmbed — это очень элегантное решение очень специфической проблемы. Вам наверное кажется, что от этого выиграют лишь несколько инженеров, работающих в больших социальных сетях, но на самом деле издательские системы, в которых пользователь может ввести URL, на удивление распространены. Найдите мне одного внутреннего инженера, которому в какой-то момент не нужно было создавать какую-то CMS. Мы можем не думать об этом в тех же терминах, но если вы принимаете ввод пользователя, вы должны подумать о том, что делать, если этот ввод содержит URL-адреса.
Теперь, когда вы знаете о oEmbed (извините), но у вас нет оправдания не уделять серьезного внимания тому, как вы будете обрабатывать URL-адреса в ваших будущих проектах.
Дополнительная информация
-------------------------
* [oEmbed спецификация](https://oembed.com/)
* [oembed](https://www.npmjs.com/package/oembed) для NodeJS
* [packagist.org/packages/embed/embed](https://packagist.org/packages/embed/embed)
* « [Объявление OEmbed: открытый стандарт для встраиваемого контента](https://blog.leahculver.com/2008/05/announcing-oembed-an-open-standard-for-embedded-content.html) », Леа Калвер | https://habr.com/ru/post/477904/ | null | ru | null |
# Масштабируемый отказоустойчивый файловый сервис на базе CTDB, GlusterFS
Статья является пошаговым руководством по построению масштабируемого отказоустойчивого файлового хранилища, доступ к которому будет осуществлен по протоколам Samba, NFS. В качестве файловой системы, которая будет непосредственно отвечать за сохранение и масштабирование файловой шары будем использовать GlusterFS, о котором было уже достаточно [написано](http://...) хабрасообществом. Так как GlusterFS — часть [Red Hat Storage](https://access.redhat.com/site/documentation/en-US/Red_Hat_Storage/2.0/pdf/Administration_Guide/Red_Hat_Storage-2.0-Administration_Guide-en-US.pdf), туториал написан для RH — like систем.
##### Каким же образом эти сервисы взаемодействуют?
###### GlusterFS
Использую версию 3.3.1, rpm-ки скачаны с официального сайта. После создания volume, клиент может получить к нему доступ несколькими способами:
* `# mount.glusterfs`
* `# mount -o mountproto=tcp,async -t nfs`
* `# mount.cifs`
Мы будем использовать первый вариант, так как в этом случае клиент устанавливает связь со всеми серверами и при отказе сервера к которому мы монтировались, мы получаем данные с рабочих серверов:
###### CTDB
Отлично механика работы описана в [этом](http://habrahabr.ru/post/91188/) посте. Хотелось бы добавить, что распределение нагрузки на кластер с использованием LVS в документации прописана только для сети NAT, по этому будем использовать Round Robbin DNS. Есть в стандартных репозиториях, так же как и SMB, NFS:
`# yum install ctdb samba nfs-utils cifs-utils`
##### Приступим
Допустим, у нас есть 2 ноды:
`gluster1, 192.168.122.100`
`gluster2, 192.168.122.101`
Еще необходима парочка IP, которые будут воплощать отказоустойчивость — мигрировать между серверами.
`192.168.122.200`
`192.168.122.201`
RR DNS для домена data выглядит так:
`; zone file fragment`
`data. 86400 IN A 192.168.122.200`
`data. 86400 IN A 192.168.122.201`
В создание volume для GlusterFS я углубляться не буду. Скажу, что нам необходимо распределенно — репликационный раздел (distributed+replicated volume). Назовём его **smb**. Для начала монтируем его локально для **каждой** ноды:
`# mount.glusterfs gluster1:smb /mnt/glustersmb`
Каждый сервер в качестве опции использует свой **hostname** . Не забываем занести запись в /etc/fstab.
Теперь правим конфигурацию Samba **(на каждом сервере)**.
`# vim /etc/samba/smb.conf`
…
`[global]`
# Основной параметр, отвечает за кластеризацию.
`clustering = yes`
# Связь с БД, которая хранит обращения пользователей (см. ссылку про механику работы )
`idmap backend = tdb2`
# Папка, с конфигурационными файлами
`private dir = /mnt/glustersmb/lock`
И туда же добавим секцию самой шары:
`[pub]`
`path = /mnt/glustersmb/lock`
`browseable = YES`
`force user = smbcli`
`force group = smbcli`
`writable = yes`
`guest ok = yes`
`guest account = smbcli`
`guest only = yes`
Папка получится для общего пользования, доступ от пользователя smbcli без авторизации. Пожже создадим его и назначим права.
Тепер **на одном** из серверов создаем папку, в которой будем размещать некоторые конфигурационные файлы CTDB
`# mkdir /mnt/glustersmb/lock`
И добавим файл:
`# touch /mnt/glustersmb/lock/lockfile`
Конфигурационный файл CTDB **на каждом** сервере приводим к виду:
`# vim /etc/sysconfig/ctdb`
`CTDB_RECOVERY_LOCK=/mnt/glustersmb/lock/lockfile`
`CTDB_PUBLIC_ADDRESSES=/etc/ctdb/public_addresses`
`CTDB_MANAGES_SAMBA=yes`
`CTDB_NODES=/etc/ctdb/nodes`
`CTDB_MANAGES_NFS=yes`
# Файл, который исполняется каждый раз, когда нода кластера CTDB изменяет свой статус (например письмецо отправлять)
`CTDB_NOTIFY_SCRIPT=/etc/ctdb/notify.sh`
Указываем наши public adresses **(на каждом сервере)**:
`# vim /etc/ctdb/public_addesses`
`192.168.122.200/24 eth0`
`192.168.122.201/24 eth0`
Указываем ноды кластера CTDB **(на каждом сервере)**:
`# vim /etc/ctdb/nodes`
`192.168.122.100`
`192.168.122.101`
SElinux я отключаю, IPtables выглядят следующим образом (естественно, **для каждого** сервера):
`# vim /etc/sysconfig/iptables`
`-A INPUT -p tcp --dport 4379 -j ctdb`
`-A INPUT -p udp --dport 4379 -j ctdb`
`-A INPUT -p tcp -m multiport --ports 137:139,445 -m comment --comment "SAMBA" -j SMB`
`-A INPUT -p udp -m multiport --ports 137:139,445 -m comment --comment "SAMBA" -j SMB`
`-A INPUT -p tcp -m multiport --ports 111,2049,595:599 -j NFS`
`-A INPUT -p udp -m multiport --ports 111,2049,595:599 -j NFS`
`-A INPUT -p tcp -m tcp --dport 24007:24220 -m comment --comment "Gluster daemon" -j ACCEPT`
`-A INPUT -p tcp -m tcp --dport 38465:38667 -m comment --comment "Gluster daemon(nfs ports)" -j ACCEPT`
# Вместо названия цепочек, можно укзать просто ACCEPT.
Вернемся к Samba и пользователю smbcli **(на каждом сервере)**:
`# useradd smbcli`
`# chown -R smbcli.smbcli /mnt/glustersmb/pub`
Предпоследние штрихи:
`# chkconfig smbd off`
`# chkconfig ctdb on`
`# service ctdb start`
Теперь можно наблюдать
`# ctdb status`
`Number of nodes:2`
`pnn:0 192.168.122.100 OK (THIS NODE)`
`pnn:1 192.168.122.101 OK`
`Generation:1112747960`
`Size:2`
`hash:0 lmaster:0`
`hash:1 lmaster:1`
`Recovery mode:NORMAL (0)`
`Recovery master:0`
Список публичных мигрирующих IP и их приналежность к серверам получаем командой
`# ctdb ip`
`Public IPs on node 0`
`192.168.122.200 node[1] active[] available[eth0] configured[eth0]`
`192.168.122.201 node[0] active[eth0] available[eth0] configured[eth0]`
Монтируем клиенту по протоколу SMB или NFS командами:
`# mount.cifs data:smb /mnt`
`# mount -o mountproto=tcp,async -t nfs data:smb /mnt`
Из личного опыта скажу, что падения сети тестирую до сих пор, результат очень даже сносный. Обрыв соединения практически не заметен. Все обьясняет [AndreyKirov](https://habrahabr.ru/users/andreykirov/)**Ликбез**
> Узел, который принял на себя IP адрес другого, знает о старых TCP соединениях только то, что они были, и не знает «TCP squence number» соединений. Соответственно, не может их продолжить. Также как и клиент, ничего не знает о том, что соединения теперь осуществляются с другим узлом.
>
>
>
> Для того чтобы избежать задержек связанных с переключением соединения используется следующий прием. Для понимания этого приема нужно понимать основные принципы функционирования протокола TCP.
>
>
>
> Новый узел, получив себе ip адрес, посылает клиенту пакет с флагом ACK и заведомо неправильным «squence number» равным нулю. В ответ клиент, в соответствии с правилами работы протокола TCP, отправляет назад пакет ACK Reply с корректным «squence number». Получив корректный «squence number» узел формирует пакет с флагом RST и этим «squence number». Получив его, клиент незамедлительно перезапускает соединение.
Приятного коддинга! | https://habr.com/ru/post/194970/ | null | ru | null |
# Автоматизация аппаратного тестирования Embedded Систем
Продолжим цикл статей об автоматизации тестирования Embedded систем. В этой статье будет рассказано как можно быстро и относительно просто интегрировать возможность управления питанием тестируемого устройства из тестового скрипта а так же получить возможность имитировать нажатия механических кнопок по команде из тестового скрипта.
Итак, что имеем:
1. Десятки Embedded устройств в которых нужно проводить тестирование новой версии FirmWare (если быть точнее — ежедневная сборка прошивки)
2. В виду особенностей процедуры загрузки FW может потребоваться необходимость сбросить питание (т.н. режим загрузки прошивки в режиме Power On Capture)
3. Хотелось бы в некоторые конкретные моменты времени по ходу выполнения тестового скрипта имитировать нажатия на механические кнопки размещенные на отладочной плате Embededed системы
Зачем может быть нужен пункт 3? В моем случае задача следующая — в случае возникновения критического Exception выполнения кода система «встает» в полумертвое состояние из которого она не выйдет пока ей не сбросят питание (еще одна причина для управления питанием). Но самое интересное в том что если в таком режиме нажать специально предназначенную для этого механическую кнопку — в последовательный порт будет выдан т.н. Exception лог — отладочная информация по которой можно будет попробовать понять в каком месте по коду произошло исключение.
Вот именно по этой причине для эффективной автоматизации тестовой установки возникла необходимость иметь возможность ресетить питание устройства и имитировать нажатия механических кнопок на отладочной плате тем самым «спасая» очень важную информацию по Exception от скорой ее утери т.к. тестовый скрипт рано или поздно поняв что ответа от устройства нет попробует ее реанимировать сбросив питание.
Небольшое лирическое отступление — иной раз за этим Exception будешь неделями бегать т.к. он возникает только иногда, когда сойдутся все звезды и будет выполнено еще куча ни кому не ведомых условий. Поэтому каждый такой отладочный лог очень важен и нужен.
Анализ схемы отладочной платы показал что кнопка просто замыкает GPIO линию подтянутую к +3.3 В на GND. Значит если «подпаяться» к кнопке и с помощью реле замыкать GPIO линию на землю — то будет то что нужно.
Далее встал вопрос выбора устройства / модуля для управления к которому выдвигались следующие требования:
* Максимальное число реле (нужно по 2 шт на каждое устройство, а устройств десятки)
* Доступ по Ethernet
* Управление URL командами
* Возможность копировать и масштабировать систему
По традиции остановились на модуле Etherent реле Laurent-128:
Модуль по всем параметрам нас послностью устроил: можно управлять сразу 14-тью устройствами (одно реле на питание, другое на нажатие кнопки) с помощью URL команд (очень удобно для скрптовых языков на которых написана автоматизация тестирования).
Схема подключения и связи отладочной платы тестируемого устройства и модуля управления показана на рисунке ниже:
«Подпайка» к контактам механической кнопки на примере одного из тестируемых устройств выглядит так:
Ура! Мехническая часть сделана. Осталось дело за малым — дописать код тестовых процедур так что бы в случае необходимости (загрузка образа прошивки после сброса питания или запись отладки по нажатию кнопки) подать команду на включение / выключение нужного реле.
Синтаксис URL команд управления простой и очевидный. Например, для того чтобы включить реле под номер 4 нужно использовать следующий HTTP адреc:
```
http://192.168.0.101/cmd.cgi?psw=Laurent&cmd=REL,4,1
```
А вот и простая функция на Perl которая вызывается из главной тестовой процедуры если нужно «дернуть» реле:
```
#---------------------------------------------------------------#
# FUNCTION:: click rele
# PARAM1: Laurent IP adress
# PARAM2: RELE ID
# PARAM3: 0 / 1 - what to do with rele
#---------------------------------------------------------------#
sub func_click_pwr_rele {
my ( $_IN_IP, $_IN_RELE, $_IN_VALUE ) = @_;
my $url;
$url = "http://".$_IN_IP."/cmd.cgi?cmd=REL,".$_IN_RELE.",".$_IN_VALUE;
my $content = get $url;
if( defined $content ) {
}
else {
func_put_reslog( "ERROR! Can't manage RELE at adress $url", "BAD" );
}
}
```
Отмечу что система работает очень надежно без сбоев и зависаний. Laurent-128 и ранее использовавшиеся Laurent-112 (на 12 реле) отработали по паре лет без сбоев и остановок с учетом ежедневной работы.
А вот и пример такого Exception который был выявлен в ходе выполнения тестов с внеочередной ежедневной сборкой прошивки. После того как тестовому скрипту стало ясно что по последовательному порту от устройства ответа нет (т.е. оно «померло») была предпринята попытка нажатия аварийной механической кнопки для записи отладки и это сработало — итоговый тестовый отчет формируемый самим тестовым скриптом наполнился полезной информацией от месте возможного падения системы для последующего анализа командой разработчиков:
 | https://habr.com/ru/post/477514/ | null | ru | null |
# Наш пятничный квест для сисадминов и не только
Мы в компании «Флант» любим IT-квесты — те, кто устраивался к нам на работу, прекрасно об этом знают. И так замечательно сложилось, что в свободное от основной занятости время мне посчастливилось придумать ещё одну головоломку.
Решение опубликовать её в хабе системного администрирования обусловлено тем, что в большей степени мы относим себя к этой категории айтишников, однако полное прохождение квеста требует проявления смекалки в разрезе более общих компетенций из области ИТ. В общем, если вам, как и нам, даже ~~(и особенно!)~~ в выходные *(а может, уже и в пятницу?)* хочется занять свой мозг интересными задачами — welcome! Мы даже обещаем приз самому быстрому победителю.
Поехали!
--------
Чтобы начать квест, достаточно посмотреть на картинку ниже. Enjoy!
Примечания
----------
* Пожалуйста, не публикуйте финальный ответ в комментариях без тега `spoiler`.
* Победителем станет первый пользователь хабры *(исключая сотрудников нашей компании, пусть они в своём большинстве этот квест ещё тоже не видели)*, оставивший комментарий с финальным ответом квеста (мы верим, что вы поймёте, когда этот ответ будет получен).
* Победителю мы отправим DIY-набор на базе Arduino — [Матрёшка Z](http://amperka.ru/product/matryoshka-z).
P.S.
----
Читайте также в нашем блоге:
* «[Vulnerable Docker VM — виртуалка-головоломка по Docker и pentesting](https://habrahabr.ru/company/flant/blog/337154/)». | https://habr.com/ru/post/352226/ | null | ru | null |
# Разработка нового статического анализатора: PVS-Studio Java
Статический анализатор PVS-Studio известен в мире C, C++ и C# как инструмент для выявления ошибок и потенциальных уязвимостей. Однако у нас мало клиентов из финансового сектора, так как выяснилось, что сейчас там востребованы Java и IBM RPG(!). Нам же всегда хотелось стать ближе к миру Enterprise, поэтому, после некоторых раздумий, мы приняли решение заняться созданием Java анализатора.
Введение
--------
Конечно, были и опасения. Легко занять рынок анализаторов в IBM RPG. Я вообще не уверен, что существуют достойные инструменты для статического анализа этого языка. В мире Java дела обстоят совсем иначе. Уже есть линейка инструментов для статического анализа, и чтобы вырваться вперед, нужно создать действительно мощный и крутой анализатор.
Тем не менее, в нашей компании был опыт использования нескольких инструментов для статического анализа Java, и мы уверены, что многие вещи мы сможем сделать лучше.
Кроме того, у нас была идея, как задействовать всю мощь нашего С++ анализатора в Java анализаторе. Но обо всём по порядку.
Дерево
------
В первую очередь нужно было определиться с тем, каким образом мы будем получать синтаксическое дерево и семантическую модель.
Синтаксическое дерево является базовым элементом, вокруг которого строится анализатор. При выполнении проверок анализатор перемещается по синтаксическому дереву и исследует его отдельные узлы. Без такого дерева производить серьезный статический анализ практически невозможно. Например, поиск ошибок с помощью регулярных выражений является [бесперспективным](https://www.viva64.com/ru/b/0087/).
При этом стоит отметить, что одного лишь синтаксического дерева недостаточно. Анализатору необходима и семантическая информация. Например, нам нужно знать типы всех элементов дерева, иметь возможность перейти к объявлению переменной и т.п.
Мы рассмотрели несколько вариантов получения синтаксического дерева и семантической модели:
* [ANTLR](http://www.antlr.org/) (с грамматикой для Java)
* [JavaParser и JavaSymbolSolver](https://javaparser.org/)
* [Eclipse's ASTParser из Eclipse JDT](https://www.eclipse.org/jdt/)
* [Spoon](http://spoon.gforge.inria.fr/)
От идеи использования ANTLR мы отказались практически сразу, так как это неоправданно усложнило бы разработку анализатора (семантический анализ пришлось бы реализовывать своими силами). В конечном итоге решили остановиться на библиотеке Spoon:
* Является не просто парсером, а целой экосистемой — предоставляет не только дерево разбора, но и возможности для семантического анализа, например, позволяет получить информацию о типах переменных, перейти к объявлению переменной, получить информацию о родительском классе и так далее.
* Основывается на Eclipse JDT и умеет компилировать код.
* Поддерживает последнюю версию Java и постоянно обновляется.
* Неплохая документация и понятный API.
Вот пример метамодели, которую предоставляет Spoon, и с которой мы работаем при создании диагностических правил:
Эта метамодель соответствует следующему коду:
```
class TestClass
{
void test(int a, int b)
{
int x = (a + b) * 4;
System.out.println(x);
}
}
```
Одной из приятных особенностей Spoon является то, что он упрощает синтаксическое дерево (удаляя и добавляя узлы) для того, чтобы с ним было проще работать. При этом гарантируется семантическая эквивалентность упрощенной метамодели исходной.
Для нас это означает, например, что не нужно больше заботиться о пропуске лишних скобок при обходе дерева. Помимо этого, каждое выражение помещается в блок, раскрываются импорты, производятся еще некоторые похожие упрощения.
Например, такой код:
```
for (int i = ((0)); (i < 10); i++)
if (cond)
return (((42)));
```
будет представлен следующим образом:
```
for (int i = 0; i < 10; i++)
{
if (cond)
{
return 42;
}
}
```
На основе синтаксического дерева производится так называемый pattern-based анализ. Это поиск ошибок в исходном коде программы по известным шаблонам кода с ошибкой. В простейшем случае анализатор ищет в дереве места, похожие на ошибку, согласно правилам, описанным в соответствующей диагностике. Количество подобных шаблонов велико и их сложность может сильно варьироваться.
Простейшим примером ошибки, обнаруживаемой с помощью pattern-based анализа, может служить следующий код из проекта jMonkeyEngine:
```
if (p.isConnected()) {
log.log(Level.FINE, "Connection closed:{0}.", p);
}
else {
log.log(Level.FINE, "Connection closed:{0}.", p);
}
```
Блоки *then* и *else* оператора *if* полностью совпадают, скорее всего, имеется логическая ошибка.
Вот еще один подобный пример из проекта Hive:
```
if (obj instanceof Number) {
// widening conversion
return ((Number) obj).doubleValue();
} else if (obj instanceof HiveDecimal) { // <=
return ((HiveDecimal) obj).doubleValue();
} else if (obj instanceof String) {
return Double.valueOf(obj.toString());
} else if (obj instanceof Timestamp) {
return new TimestampWritable((Timestamp)obj).getDouble();
} else if (obj instanceof HiveDecimal) { // <=
return ((HiveDecimal) obj).doubleValue();
} else if (obj instanceof BigDecimal) {
return ((BigDecimal) obj).doubleValue();
}
```
В данном коде находятся два одинаковых условия в последовательности вида *if (....) else if (....) else if (....)*. Стоит проверить этот участок кода на наличие логической ошибки, либо убрать дублирующий код.
Data-flow analysis
------------------
Помимо синтаксического дерева и семантической модели, анализатору необходим механизм [анализа потока данных](https://en.wikipedia.org/wiki/Data-flow_analysis).
Анализ потока данных позволяет вычислять допустимые значения переменных и выражений в каждой точке программы и, благодаря этому, находить ошибки. Мы называем эти допустимые значения виртуальными значениями.
Виртуальные значения создаются для переменных, полей классов, параметров методов и прочего при первом упоминании. Если это присваивание, механизм Data Flow вычисляет виртуальное значение путем анализа выражения стоящего справа, в противном случае в качестве виртуального значения берется весь допустимый диапазон значений для данного типа переменной. Например:
```
void func(byte x) // x: [-128..127]
{
int y = 5; // y: [5]
...
}
```
При каждом изменении значения переменной механизм Data Flow пересчитывает виртуальное значение. Например:
```
void func()
{
int x = 5; // x: [5]
x += 7; // x: [12]
...
}
```
Механизм Data Flow также выполняет обработку управляющих операторов:
```
void func(int x) // x: [-2147483648..2147483647]
{
if (x > 3)
{
// x: [4..2147483647]
if (x < 10)
{
// x: [4..9]
}
}
else
{
// x: [-2147483648..3]
}
...
}
```
В данном примере при входе в функцию о диапазоне значений переменной *x* нет никакой информации, поэтому он устанавливается в соответствии с типом переменной (от -2147483648 до 2147483647). Затем первый условный блок накладывает ограничение *x* > 3, и диапазоны объединяются. В результате в *then* блоке диапазон значений для *x*: от 4 до 2147483647, а в *else* блоке от -2147483648 до 3. Аналогичным образом обрабатывается и второе условие *x* < 10.
Кроме того, необходимо иметь возможность производить и чисто символьные вычисления. Простейший пример:
```
void f1(int a, int b, int c)
{
a = c;
b = c;
if (a == b) // <= always true
....
}
```
Здесь переменной *а* присваивается значение *c*, переменной *b* также присваивается значение *c*, после чего *а* и *b* сравниваются. В этом случае, чтобы найти ошибку, достаточно просто запомнить кусок дерева, соответствующий правой части.
Вот чуть более сложный пример с символьными вычислениями:
```
void f2(int a, int b, int c)
{
if (a < b)
{
if (b < c)
{
if (c < a) // <= always false
....
}
}
}
```
В таких случаях уже приходится решать систему неравенств в символьном виде.
Механизм Data Flow помогает анализатору находить ошибки, которые с помощью pattern-based анализа найти весьма затруднительно.
К таким ошибкам относятся:
* Переполнения;
* Выход за границу массива;
* Доступ по нулевой или потенциально нулевой ссылке;
* Бессмысленные условия (always true/false);
* Утечки памяти и ресурсов;
* Деление на 0;
* И некоторые другие.
Data Flow анализ особенно важен при поиске уязвимостей. Например, в случае, если некая программа получает ввод от пользователя, есть вероятность, что ввод будет использован для того, чтобы вызвать отказ в обслуживании, или для получения контроля над системой. Примерами могут служить ошибки, приводящие к переполнениям буфера при некоторых входных данных, или, например, SQL-инъекции. В обоих случаях для того, чтобы статический анализатор мог выявлять подобные ошибки и уязвимости, необходимо отслеживать поток данных и возможные значения переменных.
Должен сказать, что механизм анализа потока данных — это сложный и обширный механизм, а в этой статье я коснулся лишь самых основ.
Рассмотрим несколько примеров ошибок, которые можно обнаружить с помощью механизма Data Flow.
Проект Hive:
```
public static boolean equal(byte[] arg1, final int start1,
final int len1, byte[] arg2,
final int start2, final int len2) {
if (len1 != len2) { // <=
return false;
}
if (len1 == 0) {
return true;
}
....
if (len1 == len2) { // <=
....
}
}
```
Условие *len1 == len2* выполняется всегда, поскольку противоположная проверка уже была выполнена выше.
Еще один пример из этого же проекта:
```
if (instances != null) { // <=
Set oldKeys = new HashSet<>(instances.keySet());
if (oldKeys.removeAll(latestKeys)) {
....
}
this.instances.keySet().removeAll(oldKeys);
this.instances.putAll(freshInstances);
} else {
this.instances.putAll(freshInstances); // <=
}
```
Здесь в блоке *else* гарантированно происходит разыменование нулевого указателя. Примечание: здесь *instances* — это то же самое, что и *this.instances*.
Пример из проекта JMonkeyEngine:
```
public static int convertNewtKey(short key) {
....
if (key >= 0x10000) {
return key - 0x10000;
}
return 0;
}
```
Здесь переменная *key* сравнивается с числом 65536, однако, она имеет тип *short*, а максимально возможное значение для *short* — это 32767. Соответственно, условие никогда не выполняется.
Пример из проекта Jenkins:
```
public final R getSomeBuildWithWorkspace()
{
int cnt = 0;
for (R b = getLastBuild();
cnt < 5 && b ! = null;
b = b.getPreviousBuild())
{
FilePath ws = b.getWorkspace();
if (ws != null) return b;
}
return null;
}
```
В данном коде ввели переменную *cnt*, чтобы ограничить количество проходов пятью, но забыли ее инкрементировать, в результате чего проверка бесполезна.
Механизм аннотаций
------------------
Кроме того, анализатору нужен механизм аннотаций. Аннотации — это система разметки, которая предоставляет анализатору дополнительную информацию об используемых методах и классах, помимо той, что может быть получена путем анализа их сигнатуры. Разметка производится вручную, это долгий и трудоемкий процесс, так как для достижения наилучших результатов необходимо проаннотировать большое количество стандартных классов и методов языка Java. Также имеет смысл выполнить аннотирование популярных библиотек. В целом аннотации можно рассматривать как базу знаний анализатора о контрактах стандартных методов и классов.
Вот небольшой пример ошибки, которую можно обнаружить с помощью аннотаций:
```
int test(int a, int b) {
...
return Math.max(a, a);
}
```
В данном примере из-за опечатки в качестве второго аргумента метода *Math.max* была передана та же переменная, что и в качестве первого аргумента. Такое выражение является бессмысленным и подозрительным.
Зная о том, что аргументы метода *Math.max* всегда должны быть различны, статический анализатор сможет выдать предупреждение на подобный код.
Забегая вперед, приведу несколько примеров нашей разметки встроенных классов и методов (код на C++):
```
Class("java.lang.Math")
- Function("abs", Type::Int32)
.Pure()
.Set(FunctionClassification::NoDiscard)
.Returns(Arg1, [](const Int &v)
{ return v.Abs(); })
- Function("max", Type::Int32, Type::Int32)
.Pure()
.Set(FunctionClassification::NoDiscard)
.Requires(NotEquals(Arg1, Arg2)
.Returns(Arg1, Arg2, [](const Int &v1, const Int &v2)
{ return v1.Max(v2); })
Class("java.lang.String", TypeClassification::String)
- Function("split", Type::Pointer)
.Pure()
.Set(FunctionClassification::NoDiscard)
.Requires(NotNull(Arg1))
.Returns(Ptr(NotNullPointer))
Class("java.lang.Object")
- Function("equals", Type::Pointer)
.Pure()
.Set(FunctionClassification::NoDiscard)
.Requires(NotEquals(This, Arg1))
Class("java.lang.System")
- Function("exit", Type::Int32)
.Set(FunctionClassification::NoReturn)
```
Пояснения:
* *Class* – аннотируемый класс;
* *Function* – метод аннотируемого класса;
* *Pure* – аннотация, показывающая, что метод является чистым, т.е. детерминированным и не имеющим побочных эффектов;
* *Set* – установка произвольного флага для метода.
* *FunctionClassification::NoDiscard* – флаг, означающий, что возвращаемое значение метода обязательно должно быть использовано;
* *FunctionClassification::NoReturn* – флаг, означающий, что метод не возвращает управление;
* *Arg1*, *Arg2*, *...*, *ArgN* – аргументы метода;
* *Returns* – возвращаемое значение метода;
* *Requires* – контракт на метод.
Стоит отметить, что помимо ручной разметки существует еще один подход к аннотированию – автоматический вывод контрактов на основе байт-кода. Понятно, что такой подход позволяет вывести только определенные виды контрактов, но зато он дает возможность получать дополнительную информацию вообще из всех зависимостей, а не только из тех, что были проаннотированы вручную.
К слову, уже существует инструмент, который умеет выводить контракты вроде *@Nullable*, *[NotNull](https://habr.com/users/notnull/)* на основе байт-кода – [FABA](https://github.com/ilya-klyuchnikov/faba). Насколько я понимаю, производная от FABA используется в IntelliJ IDEA.
Сейчас мы тоже рассматриваем возможность добавления анализа байт-кода для получения контрактов для всех методов, так как эти контракты могли бы хорошо дополнить наши ручные аннотации.
Диагностические правила при работе часто обращаются к аннотациям. Помимо диагностик, аннотации использует механизм Data Flow. Например, используя аннотацию метода *java.lang.Math.abs*, он может точно вычислять значение для модуля числа. При этом писать какой-либо дополнительный код не приходится – только правильно разметить метод.
Рассмотрим пример ошибки из проекта Hibernate, которую можно обнаружить благодаря аннотации:
```
public boolean equals(Object other) {
if (other instanceof Id) {
Id that = (Id) other;
return purchaseSequence.equals(this.purchaseSequence) &&
that.purchaseNumber == this.purchaseNumber;
}
else {
return false;
}
}
```
В данном коде метод *equals()* сравнивает объект *purchaseSequence* с самим собой. Наверняка это опечатка и справа должно быть *that.purchaseSequence*, а не *purchaseSequence*.
Как доктор Франкенштейн собирал из частей анализатор
----------------------------------------------------
Поскольку сами по себе механизмы Data Flow и аннотаций не сильно привязаны к определенному языку, было принято решение переиспользовать эти механизмы из нашего C++ анализатора. Это позволило нам в короткие сроки получить всю мощь ядра C++ анализатора в нашем Java анализаторе. Кроме того, на это решение также повлияло и то, что эти механизмы были написаны на современном C++ с кучей метапрограммирования и шаблонной магии, а, соответственно, не очень хорошо подходят для переноса на другой язык.
Для того, чтобы связать Java часть с ядром на C++, мы решили использовать [SWIG (Simplified Wrapper and Interface Generator)](http://www.swig.org/) – средство для автоматической генерации врапперов и интерфейсов для связывания программ на C и C++ с программами, написанными на других языках. Для Java SWIG генерирует код на [JNI (Java Native Interface)](https://en.wikipedia.org/wiki/Java_Native_Interface).
SWIG отлично подходит для случаев, когда имеется уже большой объем C++ кода, который необходимо интегрировать в Java проект.
Приведу минимальный пример работы со SWIG. Предположим, у нас есть C++ класс, который мы хотим использовать в Java проекте:
CoolClass.h
```
class CoolClass
{
public:
int val;
CoolClass(int val);
void printMe();
};
```
CoolClass.cpp
```
#include
#include "CoolClass.h"
CoolClass::CoolClass(int v) : val(v) {}
void CoolClass::printMe()
{
std::cout << "val: " << val << '\n';
}
```
Сперва нужно создать [интерфейсный файл SWIG](http://www.swig.org/Doc3.0/SWIG.html) с описанием всех экспортируемых функций и классов. Также в этом файле при необходимости производятся дополнительные настройки.
Example.i
```
%module MyModule
%{
#include "CoolClass.h"
%}
%include "CoolClass.h"
```
После этого можно запускать SWIG:
```
$ swig -c++ -java Example.i
```
Он сгенерирует следующие файлы:
* CoolClass.java – класс, с которым мы будем непосредственно работать в Java проекте;
* MyModule.java – класс модуля, в который помещаются все свободные функции и переменные;
* MyModuleJNI.java – Java врапперы;
* Example\_wrap.cxx – С++ врапперы.
Теперь нужно просто добавить получившиеся .java файлы в Java проект и .cxx файл в C++ проект.
Наконец, нужно скомпилировать C++ проект в виде динамической библиотеки и подгрузить ее в Java проект с помощью *System.loadLibary()*:
App.java
```
class App {
static {
System.loadLibary("example");
}
public static void main(String[] args) {
CoolClass obj = new CoolClass(42);
obj.printMe();
}
}
```
Схематически это можно представить следующим образом:
Конечно, в реальном проекте все не настолько просто и приходится приложить чуть больше усилий:
* Для того, чтобы использовать шаблонные классы и методы из C++, их нужно инстанцировать для всех принимаемых шаблонных параметров с помощью директивы *%template*;
* В некоторых случаях может понадобиться перехватывать исключения, которые выбрасываются из C++ части в Java части. По умолчанию SWIG не перехватывает исключения из C++ (возникает segfault), однако, имеется возможность это сделать, используя директиву *%exception*;
* SWIG позволяет расширять плюсовый код на стороне Java, используя директиву *%extend*. Мы, например, в нашем проекте добавляем к виртуальным значениям метод *toString()*, чтобы можно было их просмотреть в отладчике Java;
* Для того, чтобы эмулировать RAII поведение из C++, во всех интересующих классах реализуется интерфейс *AutoClosable*;
* Механизм директоров позволяет использовать кросс-языковый полиморфизм;
* Для типов, которые аллоцируются только внутри C++ (на своём пуле памяти), убираются конструкторы и финализаторы, чтобы повысить производительность. Сборщик мусора будет игнорировать эти типы.
Подробнее обо всех этих механизмах можно почитать в [документации SWIG](http://www.swig.org/Doc3.0/SWIGDocumentation.html).
Наш анализатор собирается при помощи gradle, который зовет CMake, который, в свою очередь, зовет SWIG и собирает C++ часть. Для программистов это происходит практически незаметно, так что никаких особых неудобств при разработке мы не испытываем.
Ядро нашего C++ анализатора собирается под Windows, Linux, macOS, так что Java анализатор также работает в этих ОС.
Что из себя представляет диагностическое правило?
-------------------------------------------------
Сами диагностики и код для анализа мы пишем на Java. Это обусловлено тесным взаимодействием со Spoon. Каждое диагностическое правило является визитором, у которого перегружаются методы, в которых обходятся интересующие нас элементы:
Например, так выглядит каркас диагностики V6004:
```
class V6004 extends PvsStudioRule
{
....
@Override
public void visitCtIf(CtIf ifElement)
{
// if ifElement.thenStatement statement is equivalent to
// ifElement.elseStatement statement => add warning V6004
}
}
```
Плагины
-------
Для максимально простой интеграции статического анализатора в проект мы разработали плагины для сборочных систем Maven и Gradle. Пользователю остается только добавить наш плагин к проекту.
Для Gradle:
```
....
apply plugin: com.pvsstudio.PvsStudioGradlePlugin
pvsstudio {
outputFile = 'path/to/output.json'
....
}
```
Для Maven:
```
....
com.pvsstudio
pvsstudio-maven-plugin
0.1
path/to/output.json
....
```
После этого плагин самостоятельно получит структуру проекта и запустит анализ.
Помимо этого, мы разработали прототип плагина для IntelliJ IDEA.
Также этот плагин работает и в Android Studio.
Плагин для Eclipse сейчас находится в стадии разработки.
Инкрементальный анализ
----------------------
Мы предусмотрели режим инкрементального анализа, который позволяет проверять только измененные файлы и тем самым значительно сокращает время, необходимое для анализа кода. Благодаря этому, разработчики смогут запускать анализ так часто, как это необходимо.
Инкрементальный анализ включает в себя несколько этапов:
* Кеширование метамодели Spoon;
* Перестроение изменившейся части метамодели;
* Анализ изменившихся файлов.
Наша система тестирования
-------------------------
Для тестирования Java анализатора на реальных проектах мы написали специальный инструментарий, позволяющий работать с базой открытых проектов. Он был написан на коленке^W Python + Tkinter и является кроссплатформенным.
Он работает следующим образом:
* Тестируемый проект определенной версии выкачивается с репозитория на GitHub;
* Выполняется сборка проекта;
* В *pom.xml* или *build.gradle* добавляется наш плагин (при помощи git apply);
* Выполняется запуск статического анализатора при помощи плагина;
* Получившийся отчет сравнивается с эталоном для этого проекта.
Такой подход гарантирует, что хорошие срабатывания не пропадут в результате изменения кода анализатора. Ниже показан интерфейс нашей утилиты для тестирования.
Красным отмечаются те проекты, в отчетах которых есть какие-либо различия с эталоном. Кнопка Approve позволяет сохранить текущую версию отчета в качестве эталона.
Примеры ошибок
--------------
По традиции приведу по несколько ошибок из разных открытых проектов, которые нашел наш Java анализатор. В будущем планируется написание статей с более детальным отчетом по каждому проекту.
### Проект Hibernate
**Предупреждение PVS-Studio:** V6009 Function 'equals' receives odd arguments. Inspect arguments: this, 1. PurchaseRecord.java 57
```
public boolean equals(Object other) {
if (other instanceof Id) {
Id that = (Id) other;
return purchaseSequence.equals(this.purchaseSequence) &&
that.purchaseNumber == this.purchaseNumber;
}
else {
return false;
}
}
```
В данном коде метод *equals()* сравнивает объект *purchaseSequence* с самим собой. Скорее всего, это опечатка и справа должно быть *that.purchaseSequence*, а не *purchaseSequence*.
**Предупреждение PVS-Studio:** V6009 Function 'equals' receives odd arguments. Inspect arguments: this, 1. ListHashcodeChangeTest.java 232
```
public void removeBook(String title) {
for( Iterator it = books.iterator(); it.hasNext(); ) {
Book book = it.next();
if ( title.equals( title ) ) {
it.remove();
}
}
}
```
Срабатывание, аналогичное предыдущему – справа должно быть *book.title*, а не *title*.
### Проект Hive
**Предупреждение PVS-Studio:** V6007 Expression 'colOrScalar1.equals(«Column»)' is always false. GenVectorCode.java 2768
**Предупреждение PVS-Studio:** V6007 Expression 'colOrScalar1.equals(«Scalar»)' is always false. GenVectorCode.java 2774
**Предупреждение PVS-Studio:** V6007 Expression 'colOrScalar1.equals(«Column»)' is always false. GenVectorCode.java 2785
```
String colOrScalar1 = tdesc[4];
....
if (colOrScalar1.equals("Col") &&
colOrScalar1.equals("Column")) {
....
} else if (colOrScalar1.equals("Col") &&
colOrScalar1.equals("Scalar")) {
....
} else if (colOrScalar1.equals("Scalar") &&
colOrScalar1.equals("Column")) {
....
}
```
Здесь явно перепутали операторы и вместо '*||'* использовали '*&&'*.
### Проект JavaParser
**Предупреждение PVS-Studio:** V6001 There are identical sub-expressions 'tokenRange.getBegin().getRange().isPresent()' to the left and to the right of the '&&' operator. Node.java 213
```
public Node setTokenRange(TokenRange tokenRange)
{
this.tokenRange = tokenRange;
if (tokenRange == null ||
!(tokenRange.getBegin().getRange().isPresent() &&
tokenRange.getBegin().getRange().isPresent()))
{
range = null;
}
else
{
range = new Range(
tokenRange.getBegin().getRange().get().begin,
tokenRange.getEnd().getRange().get().end);
}
return this;
}
```
Анализатор обнаружил, что слева и справа от оператора *&&* стоят одинаковые выражения (при этом все методы в цепочке вызовов являются чистыми). Скорее всего, во втором случае необходимо использовать *tokenRange.getEnd()*, а не *tokenRange.getBegin()*.
**Предупреждение PVS-Studio:** V6016 Suspicious access to element of 'typeDeclaration.getTypeParameters()' object by a constant index inside a loop. ResolvedReferenceType.java 265
```
if (!isRawType()) {
for (int i=0; i(typeDeclaration.getTypeParams().get(0),
typeParametersValues().get(i)));
}
}
```
Анализатор обнаружил подозрительный доступ к элементу коллекции по константному индексу внутри цикла. Возможно, в данном коде присутствует ошибка.
### Проект Jenkins
**Предупреждение PVS-Studio:** V6007 Expression 'cnt < 5' is always true. AbstractProject.java 557
```
public final R getSomeBuildWithWorkspace()
{
int cnt = 0;
for (R b = getLastBuild();
cnt < 5 && b ! = null;
b = b.getPreviousBuild())
{
FilePath ws = b.getWorkspace();
if (ws != null) return b;
}
return null;
}
```
В данном коде ввели переменную *cnt*, чтобы ограничить количество проходов пятью, но забыли ее инкрементировать, в результате чего проверка бесполезна.
### Проект Spark
**Предупреждение PVS-Studio:** V6007 Expression 'sparkApplications != null' is always true. SparkFilter.java 127
```
if (StringUtils.isNotBlank(applications))
{
final String[] sparkApplications = applications.split(",");
if (sparkApplications != null && sparkApplications.length > 0)
{
...
}
}
```
Проверка на *null* результата, возвращаемого методом *split*, бессмысленна, так как этот метод всегда возвращает коллекцию и никогда не возвращает *null*.
### Проект Spoon
**Предупреждение PVS-Studio:** V6001 There are identical sub-expressions '!m.getSimpleName().startsWith(«set»)' to the left and to the right of the '&&' operator. SpoonTestHelpers.java 108
```
if (!m.getSimpleName().startsWith("set") &&
!m.getSimpleName().startsWith("set")) {
continue;
}
```
В данном коде слева и справа от оператора && стоят одинаковые выражения (при этом все методы в цепочке вызовов являются чистыми). Скорее всего, в коде присутствует логическая ошибка.
**Предупреждение PVS-Studio:** V6007 Expression 'idxOfScopeBoundTypeParam >= 0' is always true. MethodTypingContext.java 243
```
private boolean
isSameMethodFormalTypeParameter(....) {
....
int idxOfScopeBoundTypeParam = getIndexOfTypeParam(....);
if (idxOfScopeBoundTypeParam >= 0) { // <=
int idxOfSuperBoundTypeParam = getIndexOfTypeParam(....);
if (idxOfScopeBoundTypeParam >= 0) { // <=
return idxOfScopeBoundTypeParam == idxOfSuperBoundTypeParam;
}
}
....
}
```
Здесь опечатались во втором условии и вместо *idxOfSuperBoundTypeParam* написали *idxOfScopeBoundTypeParam*.
### Проект Spring Security
**Предупреждение PVS-Studio:** V6001 There are identical sub-expressions to the left and to the right of the '||' operator. Check lines: 38, 39. AnyRequestMatcher.java 38
```
@Override
@SuppressWarnings("deprecation")
public boolean equals(Object obj) {
return obj instanceof AnyRequestMatcher ||
obj instanceof security.web.util.matcher.AnyRequestMatcher;
}
```
Срабатывание аналогично предыдущему – здесь имя одного и того же класса записано разными способами.
**Предупреждение PVS-Studio:** V6006 The object was created but it is not being used. The 'throw' keyword could be missing. DigestAuthenticationFilter.java 434
```
if (!expectedNonceSignature.equals(nonceTokens[1])) {
new BadCredentialsException(
DigestAuthenticationFilter.this.messages
.getMessage("DigestAuthenticationFilter.nonceCompromised",
new Object[] { nonceAsPlainText },
"Nonce token compromised {0}"));
}
```
В данном коде забыли добавить *throw* перед исключением. В результате объект исключения *BadCredentialsException* создается, но никак не используется, т.е. исключение не выбрасывается.
**Предупреждение PVS-Studio:** V6030 The method located to the right of the '|' operators will be called regardless of the value of the left operand. Perhaps, it is better to use '||'. RedirectUrlBuilder.java 38
```
public void setScheme(String scheme) {
if (!("http".equals(scheme) | "https".equals(scheme))) {
throw new IllegalArgumentException("...");
}
this.scheme = scheme;
}
```
В данном коде использование оператора *|* неоправданно, так как при его использовании правая часть будет вычислена даже в случае, если левая часть уже является истинной. В данном случае это не имеет практического смысла, поэтому оператор *|* стоит заменить на *||*.
### Проект IntelliJ IDEA
**Предупреждение PVS-Studio:** V6008 Potential null dereference of 'editor'. IntroduceVariableBase.java:609
```
final PsiElement nameSuggestionContext =
editor == null ? null : file.findElementAt(...); // <=
final RefactoringSupportProvider supportProvider =
LanguageRefactoringSupport.INSTANCE.forLanguage(...);
final boolean isInplaceAvailableOnDataContext =
supportProvider != null &&
editor.getSettings().isVariableInplaceRenameEnabled() && // <=
...
```
Анализатор обнаружил, что в данном коде может произойти разыменование нулевого указателя *editor*. Стоит добавить дополнительную проверку.
**Предупреждение PVS-Studio:** V6007 Expression is always false. RefResolveServiceImpl.java:814
```
@Override
public boolean contains(@NotNull VirtualFile file) {
....
return false & !myProjectFileIndex.isUnderSourceRootOfType(....);
}
```
Мне сложно сказать, что имел в виду автор, но такой код выглядит весьма подозрительно. Даже если вдруг ошибки здесь нет, думаю, стоит переписать это место так, чтобы не смущать анализатор и других программистов.
**Предупреждение PVS-Studio:** V6007 Expression 'result[0]' is always false. CopyClassesHandler.java:298
```
final boolean[] result = new boolean[] {false}; // <=
Runnable command = () -> {
PsiDirectory target;
if (targetDirectory instanceof PsiDirectory) {
target = (PsiDirectory)targetDirectory;
} else {
target = WriteAction.compute(() ->
((MoveDestination)targetDirectory).getTargetDirectory(
defaultTargetDirectory));
}
try {
Collection files =
doCopyClasses(classes, map, copyClassName, target, project);
if (files != null) {
if (openInEditor) {
for (PsiFile file : files) {
CopyHandler.updateSelectionInActiveProjectView(
file,
project,
selectInActivePanel);
}
EditorHelper.openFilesInEditor(
files.toArray(PsiFile.EMPTY\_ARRAY));
}
}
}
catch (IncorrectOperationException ex) {
Messages.showMessageDialog(project,
ex.getMessage(),
RefactoringBundle.message("error.title"),
Messages.getErrorIcon());
}
};
CommandProcessor processor = CommandProcessor.getInstance();
processor.executeCommand(project, command, commandName, null);
if (result[0]) { // <=
ToolWindowManager.getInstance(project).invokeLater(() ->
ToolWindowManager.getInstance(project)
.activateEditorComponent());
}
```
Подозреваю, что здесь забыли как-либо изменить значение в *result*. Из-за этого анализатор сообщает о том, что проверка *if (result[0])* является бессмысленной.
Заключение
----------
Java направление является весьма разносторонним – это и desktop, и android, и web, и многое другое, поэтому у нас есть большой простор для деятельности. В первую очередь, конечно, будем развивать те направления, что будут наиболее востребованы.
Вот наши планы на ближайшее будущее:
* Вывод аннотаций на основе байт-кода;
* Интеграция в проекты на Ant (кто-то его еще использует в 2018?);
* Плагин для Eclipse (в процессе разработки);
* Еще больше диагностик и аннотаций;
* Совершенствование механизма Data Flow.
Также предлагаю желающим поучаствовать в тестировании альфа-версии нашего Java анализатора, когда она станет доступной. Для этого напишите нам [в поддержку](https://www.viva64.com/ru/about-feedback/). Мы внесем ваш контакт в список и напишем вам, когда подготовим первую альфа-версию.
[](https://www.viva64.com/en/b/0572/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Egor Bredikhin. [Development of a new static analyzer:](https://www.viva64.com/en/b/0572/)
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio, версия 2015](https://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/414669/ | null | ru | null |
# C++ и дружба
Открыл для себя забавный факт: оказывается, у классов в C++ могут быть воображаемые друзья. Пример:
`**class** Fred {`
Заметьте, что в программе нет объявления класса Joe, однако программа компилируется без ошибок (и без предупреждений). То есть Джо не существует, его можно назвать воображаемым другом Фреда. Такое возможно, поскольку отношение дружбы влияет только на компиляцию класса, **который объявлен** другом. А класс, **объявивший** кого-то своим другом, будет скомпилирован одинаково независимо от того, что представляют собой его друзья и существуют ли они. | https://habr.com/ru/post/63559/ | null | ru | null |
# О декораторах, сквозной функциональности, CQRS и слоеной архитектуре
 Разработчик SimpleInjector [очень любит «декораторы»](http://simpleinjector.readthedocs.io/en/latest/aop.html#decoration), особенно в сочетании с дженериками вида
`[QueryHandler](https://cuttingedge.it/blogs/steven/pivot/entry.php?id=92), [CommandHanler](https://cuttingedge.it/blogs/steven/pivot/entry.php?id=91)`.
Такой подход позволяет «навешивать» на обработчики то, что принято называть [cross-cutting concerns](https://stackoverflow.com/questions/23700540/cross-cutting-concern-example) без ~~регистрации и смс~~ [interception](http://simpleinjector.readthedocs.io/en/latest/InterceptionExtensions.html) и особой уличной магии вроде [Fody](https://github.com/Fody/Fody) или [PostSharp](https://www.postsharp.net/).
CQRS не top level architecture, поэтому хочется иметь такие-же декораторы и для классических Application Service. Под катом я расскажу как это сделать.
### Что такое сквозная функциональность (cross-cutting concern)
Сross-cutting concern — термин из АОП. К сквозной относится «вспомогательная» функциональность модуля, не относящаяся напрямую к выполняемой задаче, но необходимая, например:
* синхронизация
* обработка ошибок
* валидация
* управление транзациями
* кеширование
* логирование
* мониторинг
Эту логику обычно [сложно отделить](https://habrahabr.ru/post/114649/) от основной. Обратите внимание на два примера ниже.
#### Код без cross-cutting concern
```
public Book GetBook(int bookId)
=> dbContext.Books.FirstorDefault(x => x.Id == bookId);
```
#### Код с cross-cutting concern
```
public Book GetBook(int bookId)
{
if (!SecurityContext.GetUser().HasRight("GetBook"))
throw new AuthException("Permission Denied");
Log.debug("Call method GetBook with id " + bookId);
Book book = null;
String cacheKey = "getBook:" + bookId;
try
{
if (cache.contains(cacheKey))
{
book = cache.Get(cacheKey);
}
else
{
book = dbContext.Books.FirstorDefault(x => x.Id == bookId);
cache.Put(cacheKey, book);
}
}
catch(SqlException e)
{
throw new ServiceException(e);
}
Log.Debug("Book info is: " + book.toString());
return book;
}
}
```
Вместо одной строчки получилось больше двадцати. И главное, этот код придется повторять снова и снова. На помощь приходят [декораторы](https://ru.wikipedia.org/wiki/%D0%94%D0%B5%D0%BA%D0%BE%D1%80%D0%B0%D1%82%D0%BE%D1%80_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)).
> Декоратор (англ. Decorator) — структурный шаблон проектирования, предназначенный для динамического подключения дополнительного поведения к объекту. Шаблон Декоратор предоставляет гибкую альтернативу практике создания подклассов с целью расширения функциональности.
Декораторы в CQRS
-----------------
Например, хочется включить глобальную валидацию. Достаточно объявить вот такой декоратор:
```
public class ValidationCommandHandlerDecorator : ICommandHandler
{
private readonly IValidator validator;
private readonly ICommandHandler decoratee;
public ValidationCommandHandlerDecorator(IValidator validator,
ICommandHandler decoratee)
{
this.validator = validator;
this.decoratee = decoratee;
}
void ICommandHandler.Handle(TCommand command)
{
// validate the supplied command (throws when invalid).
this.validator.ValidateObject(command);
// forward the (valid) command to the real command handler.
this.decoratee.Handle(command);
}
}
```
И зарегистрировать его для всех обработчиков команд:
```
container.RegisterDecorator(
typeof(ICommandHandler<>),
typeof(ValidationCommandHandlerDecorator<>));
```
Теперь для всех реализаций интерфейса `ICommandHandler` валидация будет происходить в декораторе, а код обработчиков останется простым.
```
public interface ICommandHandler
{
TOutput Handle(TInput command);
}
public class AddBookCommandHandler: ICommandHandler
{
public bool Handle(BookDto dto)
{
var entity = Mapper.Map(dto);
dbContext.Books.Add(entity);
dbContext.SaveChanges();
return entity.Id;
}
}
```
Но тогда придется писать по набору декораторов для `ICommandHandler` и `IQueryHandler`. Можно конечно обойти эту проблему [с помощью делегатов](https://habrahabr.ru/post/347908/#decorator). Но получается не очень красиво и применимо только к CQRS, т.е. только в каком-то отдельном ограниченном контексте (bounded context) приложения, где [CQRS оправдан](https://habrahabr.ru/post/347908/).
Различие `IHandler` и `Application Service`
-------------------------------------------
Основная проблема с глобальным применением декораторов для сервисного слоя в том, что интерфейсы сервисов сложнее, чем generic handler'ы. Если все обработчики реализуют вот такой generic-интерфейс:
```
public interface ICommandHandler
{
TOutput Handle(TInput command);
}
```
То сервисы обычно реализуют по одному методу на каждый use case
```
public interface IAppService
{
ResponseType UseCase1(RequestType1 request);
ResponseType UseCase2(RequestType2 request);
ResponseType UseCase3(RequestType3 request);
//...
ResponseType UseCaseN(RequestTypeN request);
}
```
Абстрактный декоратор с валидацией уже не применишь, придется писать по декоратору на каждый сервис, что убивает саму идею написать один раз код валидации и забыть про него. Более того, проще тогда писать код валидации внутри методов, чем декорировать их.
MediatR
-------
Для CQRS можно решить проблему дублирования декораторов, если ввести интерфейс `IRequestHandler` и использовать его для `Command` и `Query`. Разделение на подсистемы чтения и записи в этом случае ложится на naming conventions. `SomeCommandRequestHandler: IRequestHandler` — очевидно, обработчик команд, а `SomeQueryRequestHandler: IRequestHandler` — запросов. такой подход реализован в [MediatR](https://github.com/jbogard/MediatR/wiki). В качестве альтернативы декораторам библиотека предоставляет механизм [behaviors](https://github.com/jbogard/MediatR/wiki/Behaviors).
`IRequestHandler` → `IUseCaseHandler`
-------------------------------------
Почему бы не переименовать интерфейс `IRequestHandler` в `IUseCaseHandler`. Обработчики запросов и комманд — [холистические абстракции](https://habrahabr.ru/post/347908/#holistic), значит каждый из них обрабатывает use case целиком. Тогда можно переписать архитектуру CQRS следующим образом:
```
public interface IUseCaseHandler
{
TOutput Handle(TInput command);
}
public interface IQueryHandler
: IUseCaseHandler
where TInput: IQuery
{
}
public interface ICommandHandler
: IUseCaseHandler
where TInput: ICommand
{
}
```
Теперь «общие» декораторы можно вешать на `IUseCaseHandler`. При этом отдельно написать декораторы для `ICommandHandler` и `IQueryHandler`, например для независимого управления транзакциями.
Декораторы для Application Service
----------------------------------
Интерфейс `IUseCaseHandler` мы сможем использовать и в Application Services, если воспользуемся [явной реализацией](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/interfaces/explicit-interface-implementation).
```
public class AppService
: IAppService
: IUseCaseHandler
: IUseCaseHandler
: IUseCaseHandler
//...
: IUseCaseHandler
{
public ResponseType1 UseCase1(RequestType1 request)
{
//...
}
IUseCaseHandler.Handle(RequestType1 request)
=> UseCase1(request);
//...
ResponseTypeN UseCaseN(RequestTypeN request)
{
//...
}
IUseCaseHandler.Handle(RequestTypeN request)
=> UseCaseN(request);
//...
}
```
В прикладном коде необходимо использовать интерфейсы `IUseCaseHandler`, а не `IAppService`, потому что декораторы будут применены только к generic-интерфейсу.
Обработка ошибок
----------------
Вернемся к примеру с валидацией. Валидатор в коде ниже выбрасывает исключение при получении неверной команды. Использовать исключения для обработки пользовательского ввода — [вопрос дискуссионный](https://habrahabr.ru/post/347284/).
```
void ICommandHandler.Handle(TCommand command)
{
// validate the supplied command (throws when invalid).
this.validator.ValidateObject(command);
// forward the (valid) command to the real command handler.
this.decoratee.Handle(command);
}
```
Если вы предпочитаете явно указывать в сигнатуре метода, что выполнение может закончиться неудачей, пример выше можно переписать так:
```
Result ICommandHandler.Handle(TCommand command)
{
return this.validator.ValidateObject(command) && this.decoratee.Handle(command);
}
```
Таким образом можно будет дополнительно разделить декораторы по типу возвращаемого значения. Например, логировать методы, возвращающие `Result` не так, как методы, возвращающие необернутые значения. | https://habr.com/ru/post/353258/ | null | ru | null |
# DSW Reports — генератор отчетов DeepSeeWeb
DSW Reports — генератор отчетов DeepSeeWeb
==========================================
Часто в аналитических приложениях пользователям нужно периодически формировать и рассылать PDF-отчёты, состоящие из элементов аналитической панели. В разработках на технологиях InterSystems эту задачу решает проект [DSW Reports](https://github.com/intersystems-community/dsw-reports), который является расширением DeepSeeWeb. В этой статье будет описано как пользоваться DSW Reports для генерации PDF-отчетов и рассылки их по электронной почте.
Что такое DSW Reports?
----------------------
Составной частью [InterSystems IRIS Data Platform](https://www.intersystems.com/resources/detail/intersystems-iris-data-platform/) является технология для разработки аналитических приложений [InterSystems IRIS Business Intelligence](https://www.intersystems.com/products/intersystems-iris/analytics/) (ранее известная как DeepSee). Существует отдельный проект [DeepSeeWeb](https://github.com/intersystems-ru/DeepSeeWeb), который использует более современный web-интерфейс (AngularJS) для визуализации аналитических панелей InterSystems IRIS BI. Для общения с серверной частью DeepSeeWeb использует [MDX2JSON](https://github.com/intersystems-ru/Cache-MDX2JSON) – проект, который предоставляет REST API доступ к InterSystems IRIS BI.
Про DeepSeeWeb и MDX2JSON мы уже писали в статьях [один](https://habr.com/company/intersystems/blog/335586/) и [два](https://habr.com/company/intersystems/blog/351992/).
[DSW Reports](https://github.com/intersystems-community/dsw-reports) — это расширение DSW, написанное на AngularJS, которое реализует основной функционал для автоматической генерации отчётов. DSW Reports использует [DeepSeeWeb](https://github.com/intersystems-ru/DeepSeeWeb) для отрисовки виджетов и [MDX2JSON](https://github.com/intersystems-ru/Cache-MDX2JSON) для обработки MDX-запросов.
### Возможности:
* Отрисовка выбранных виджетов с установленными фильтрами.
* Вывод результатов вычисления произвольных MDX-запросов.
* Автоматическая печатать PDF-отчётов и рассылка их по почте
* Кастомизация внешнего вида отчёта при помощи CSS-стилей
Создание отчёта
---------------
Для формирования отчёта в DSW Reports достаточно создать как минимум 2 файла:
* **index.html** — каркас и главная страница отчёта, обычно не изменяется.
* **config.js** — конфигурация отчёта, меняется для разных отчётов, отвечает за наполнение отчёта.
В файле конфигурации отчёта должна обязательно содержаться функция **getConfiguration**.
```
// Общие настройки отчёта
function getConfiguration(params){...}
```
Функция **getConfiguration** принимает обьект *params*, который содержит в себе параметры из строки URL и дополнительный параметр "***server***", являющийся адресом сервера. Параметр "***server***" имеет вид: `protocol://host:port`.
Благодаря объекту *params* можно передавать в отчёт любые данные через URL-строку. Например, если требуется изменять фильтры виджетов по желанию, тогда передаём с URL-параметр "***filter***" и он будет доступен через объект *params*.
```
///dsw/reports/report\_dir/index.html?filter=NOW
function getConfiguration(params){
var filter = params["filter"]; // filter = "NOW"
}
```
Функция **getConfiguration** возвращает объект, содержащий 3 свойства:
* *REPORT\_NAME* — название отчёта
* *BLOCKS* — массив блоков отчёта
* *NAMESPACE* — область с данными для отчёта
Рассмотрим подробнее массив блоков *BLOCKS*. Блок — объект с настройками виджета, настройками вычисляемых полей и т.д.
### Вид блока:
```
{
"title": String, //Заголовок блока
"note": String, //Замечания под блоком. Могут содержать HTML код
"widget": { //Настройки iframe виджета:
"url": String, //URL источника для iframe
"height": Number, //Высота iframe
"width": Number //Ширина iframe
},
"totals":[{ //Настройки значений вычисляемых с помощью MDX
"mdx": String //MDX-запрос
"strings": [{ //Строки значений из запроса
"title": String, //Заголовок строки. Может использовать HTML.
"value": String, //Значение строки по умолчанию
"value_append": String, //Суффикс для значения.
//Может использоваться для знаков %, $ и т.д.
//% преобразует значение в процентное (x * 100).
//Может использовать HTML.
"row": Number //Номер строки MDX-запроса,
//из которой берётся значение.
//По умолчанию 0.
},{...}]
},{...}]}
```
Все поля обязательны, если поле не нужно лучше выставить его пустой строкой.
**Пример блока**
```
{
title: "Persons",
note: "",
widget: {
url: server + "/dsw/index.html#!/d/KHAB/Khabarovsk%20Map.dashboard" +
"?widget=1&height=420&ns=" + namespace,
width: 700,
height: 420
}
}
```
**Ещё пример**
```
{
title: "Khabarovsky krai",
note: "Something note (only static)",
widget: {
url: server + "/dsw/index.html#!/d/KHAB/Khabarovsk%20Map.dashboard" +
"?widget=0&height=420&isLegend=true&ns=" + namespace,
width: 495,
height: 420
},
totals: [{
mdx: "SELECT NON EMPTY " +
"[Region].[H1].[Region].CurrentMember.Properties(\"Population\") ON 0,"+
"NON EMPTY {[Region].[H1].[Region].&[Хабаровск]," +
"[Region].[H1].[Region].&[Комсомольск-на-Амуре],"+
"[Region].[H1].[Region].&[Комсомольский район]} ON 1 FROM [KHABCUBE]",
strings: [{
title: "Khabarovsk: ",
value: "None",
value_append: " чел."
}, {
title: "Komsomolsk-on-Amur:
",
value: "None",
value_append: " чел.",
row: 1
}, {
title: "Komsomolsky district:
",
value: "None",
value_append: " чел.",
row: 2
}]
}]
}
```
### Чем заполнять блок?
Основные поля для заполнения в блоке — это **url** для настроек виджета и **mdx** для настроек вычисляемых значений.
* **MDX** можно составить и вручную, но рекомендуется делать это при помощи визуального конструктора [Analyzer](https://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=D2ANLY_ch_intro), встроенного в InterSystems IRIS BI/DeepSee.
* **URL** можно получить при помощи DeepSeeWeb. Виджеты встроенные в отчёт — это элементы *iframe*, источниками которых являются виджеты DeepSeeWeb. Чтобы получить ссылку на источник, выберите пункт *"Share"* в контекстном меню виджета.
### Кастомизация внешнего вида отчёта
Вместе с библиотеками отчёта поставляется файл **style.css** позволяющий редактировать внешний вид отчёта. В нем содержится стандартный набор классов, управляющий всеми элементами отчёта. Также можно добавлять свои классы стилей и использовать их в файле **index.html**.
Рассылка по E-mail
------------------
Допустим отчёт уже готов и размещён в папке отчетов в DeepSeeWeb. Т.е. интерактивный HTML-отчет теперь доступен по ссылке. Что нужно сделать, чтобы конвертировать его в PDF и разослать по почте? Это автоматически сделают [pthantomjs](http://phantomjs.org/) и встроенный SMTP-клиент. Как установить и настроить phantomjs можно посмотреть здесь ([windows](https://youtu.be/L8Lw53MjDdY), [ubuntu](https://www.vultr.com/docs/how-to-install-phantomjs-on-ubuntu-16-04)). Далее нужно настроить SMTP-клиент и создать задание в [Менеджере задач](https://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=GSA_manage_taskmgr).
### Настройка SMTP
Все настройки производятся в терминале.
1. Сначала нужно настроить почту для рассылки
```
// Функция для настройки SMTP
do ##class(DSW.Report.EmailSender).setConfig(server, port, username,
password, sender, SSLConfig)
```
* **server** — адрес SMTP-сервера.
* **port** — порт для исходящих собщений.
* **username** и **password** — аутентификационные данные.
* **sender** — E-mail адрес рассылки.
* **SSLConfig** — *Опционально*. Имя [SSL-конфигурации](https://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=GCAS_ssltls).
2. Затем следует настроить список пользователей для рассылки
```
// Функция для добавления пользователя
do ##class(DSW.Report.EmailSender).addRecipient(email)
// Функция для удаления пользователя
do ##class(DSW.Report.EmailSender).deleteRecipient(email)
```
3. После предыдущих шагов можно запустить рассылку
```
// Функция запускающая рассылку
do ##class(DSW.Report.Task).Run(url, reportname)
```
* **url** — ссылка на отчёт.
* **reportname** — название отчёта. Используется при генерации PDF.
### Автоматический запуск рассылки
Для автоматизации рассылки воспользуемся [Менеджером задач](https://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=GSA_manage_taskmgr). Создадим новую задачу со следующими параметрами:
1. На первой странице настраивается область запуска и прописываем нашу функцию для запуска рассылки.
2. На второй странице настраивается время и переодичность запуска задачи.
3. Последний шаг — нажимаем *"Завершить"*.
Всё, после всех этих манипуляций у нас получился автогенерируемый отчёт, состоящий из виджетов DeepSeeWeb, который в заданное время рассылается по почте в виде PDF.
→ Пример готового отчёта можно посмотреть [здесь](https://bit.ly/2MhMLfh)
→ Файл конфигурации этого отчёта посмотреть [здесь](https://github.com/intersystems-community/dc-analytics/blob/master/src/reports/week/config.js)
→ А [здесь](https://community.intersystems.com/post/analysing-developer-community-activity-using-intersystems-analytics-technology-deepsee) можно подписаться на еженедельную доставку отчетов
→ [Ссылка](https://github.com/intersystems-community/dsw-reports) на репозиторий | https://habr.com/ru/post/419433/ | null | ru | null |
# Вникаем в include и extend
*Примечание переводчика: перед прочтением этого поста рекомендую сначала ознакомиться с постом [Вникаем в метаклассы Ruby](http://habrahabr.ru/post/143990/).*
Все рубисты знакомы с формальными определениями для *include* и *extend*. Вы делаете *include* модуля, чтобы добавить методы экземпляра класса, и *extend* — чтобы добавить методы класса. К сожалению, данные определения не совсем точны. Они не могут объяснить почему мы используем *instance.extend(Module)*, чтобы добавить методы объекту. Разве не должны мы в этом случае использовать *instance.include(Module)*? Чтобы разобраться в этом вопросе, начнем с выяснения где же хранятся методы.
#### Методы, которые я храню для тебя и парень, который хранит мои методы
Объекты в Ruby не хранят свои собственные методы. Вместо этого они создают синглтон-класс, чтобы он хранил их методы.
```
class A
def self.who_am_i
puts self
end
def speak_up(input)
puts input.upcase
end
end
```
Интерпретатор создаст класс *A* и прикрепленный к нему синглтон-класс (мы будем ссылаться на синглтон-класс объекта используя префикс **‘** перед именем объекта). Любые методы экземпляра класса (как *speak\_up*) добавляются к методам, хранящимся в классе *A*. Методы класса (как *who\_am\_i*) хранятся в классе *‘A*.
```
A.singleton_methods # методы в классе ‘A
#=> [:who_am_i]
```
Тоже самое происходит с экземплярами класса. Если у нас есть объект класса *A* и мы добавляем к нему метод, мы не можем хранить этот метод внутри самого объекта. Запомните — объекты в Ruby не хранят свои собственные методы.
```
a = A.new
def a.not_so_loud(input)
puts input.downcase
end
```
Здесь опять создается синглтон-класс для объекта "*a*", чтобы он хранил метод *not\_so\_loud*.
Теперь у нас есть метод, который принадлежит только объекту "*a*" и не затрагивает другие объекты класса *A*.
#### Я — свой отец?
Класс *A* содержит методы и информацию о цепи наследования, нужные для объекта "*a*" и всех остальных объектов класса *A*. Точно также синглтон-класс *‘A* содержит методы и информацию о цепи наследования для класса *A*. Вы можете считать класс *A* объектом класса *‘A*. Уловка в том, что мы не можем напрямую обращаться к синглтон-классу *‘A*. Это значит, что нам нужно как-то различать добавление методов в *A* и в *‘A*. Тут то *include* и *extend* и вступают в игру.
#### include
Когда вы делаете *include* модуля в объект, вы добавляете методы в цепь наследования объекта.
```
class A
include M
end
```
В этом легко убедиться, проверив предков класса *A*.
```
A.ancestors
#=> [A, M, Object, Kernel, BasicObject]
```
#### extend
*extend* — это тоже самое, что сделать *include*, но для синглтон-класса объекта.
```
class A
extend M
end
```
И снова мы можем подтвердить это, проверив предков класса *‘A*.
```
A.singleton_class.ancestors
#=> [M, Class, Module, Object, Kernel, BasicObject]
```
Также мы можем использовать *extend* и для объекта.
```
a = A.new
a.extend(M)
a.singleton_class.ancestors
#=> [M, A, Object, Kernel, BasicObject]
```
Если вы думаете об *extend* как о способе просто добавить методы класса, то все что мы сейчас сделали не имеет особого смысла. Однако, если вы посмотрите на это как на способ добавить методы к синглтон-классу объекта, то приведенные выше примеры станут яснее.
#### Хук included
Каждый вызов *include* проверяет подключаемый модуль на наличие метода *included*. Этот метод исполняется, когда модуль подключается, используя *include*. Это как конструктор (*initialize*) для подключений. Как вы возможно догадались, у *extend* для этих целей есть собственный метод — *extended*. Поэтому когда вы хотите добавить сразу и методы класса и методы экземпляра класса, вы можете использовать для этого хук *included*.
```
module M
def self.included(base)
base.extend(ClassMethods)
end
def speak_up(input)
puts input.upcase
end
module ClassMethods
def who_am_i
puts self
end
end
end
class C
include M
end
c = C.new
```
Сначала мы включаем модуль *M* в цепь наследования класса *C*.
Затем мы расширяем класс *C*, добавляя методы в цепь наследования класса *‘C*.
#### Заключение
Когда начинаешь копать глубже типичного использования *include* и *extend*, то обнаруживаешь нечто странное и пугающее. Однако стоит понять реализацию лежащую в основе и все сразу обретает смысл. Давайте теперь дадим определение *include* и *extend* еще раз.
***include*** — добавляет методы модуля объекту.
***extend*** — вызывает *include* для синглтон-класса объекта.
Если вас интересует еще больше деталей о том, как работает интерпретатор, то я рекомендую к просмотру выступление [Patrick Farley на Ruby Internals](http://mwrc2008.confreaks.com/11farley.html).
> Примечание переводчика: еще один момент почему мы не можем использовать *instance.include(Module)* — это то, что метод *include* является приватным методом класса *Module*. В целом же до прочтения этой статьи я тоже не так представлял себе работу *extend* и *include*, поэтому посчитал стоящим ее перевести.
>
>
>
> Внесу еще некоторую ясность: то, что в статье названо «синглтон-класс» (singleton class), имеет и другие названия: метакласс (metaclass) и айгенкласс (eigenclass). Это все одна и та же сущность, для которой в сообществе Ruby пока нет «официального» названия. Я использовал «синглтон-класс», т.к. это ближе к оригиналу. Однако Matz'у (создателю языка) больше импонирует термин eigenclass. | https://habr.com/ru/post/143483/ | null | ru | null |
# Соединяем блог и Livejournal через XML-RPC
XML remote procedure call на самом деле очень простая процедура, при помощи которой я теперь могу писать в своём блоге и копировать статью в livejournal. С виду, самым простым решением вероятно выглядело бы создание такого процесса, где передача данных на сервер LJ происходил бы браузером. Достаточно создать отдельный iframe, в него поместить форму, в которую копировать содержание из другой формы и в итоге публиковать в LJ. Но — во первых это уродливо, во вторых не факт что так можно исхитриться.Гораздо проще и удобнее все данные передать через xml-rpc. Для этого — устанавливаем готовую [библиотеку](http://phpxmlrpc.sourceforge.net/) и используем функцию..
`function post2livejournal($subject,$event,$time=0) {
require_once('lib/xmlrpc.inc');
$lj_userid='my_livejournal_username';
$lj_passwd='my_secret_password';
if (!$time)$time=time();
$year=date('Y',$time);
$month=date('m',$time);
$day=date('d',$time);
$hour=date('H',$time);
$minute=date('i',$time);
$client=new xmlrpc_client("/interface/xmlrpc", "www.livejournal.com", 80);
$params = new xmlrpcval( array(
'username' => new xmlrpcval($lj_userid,'string'),
'password' => new xmlrpcval($lj_passwd,'string'),
'ver' => new xmlrpcval('1','string'),
'lineendings' => new xmlrpcval('pc','string'),
'event' => new xmlrpcval($event,'string'),
'subject' => new xmlrpcval($subject,'string'),
'year' => new xmlrpcval($year,'int'),
'mon' => new xmlrpcval($month,'int'),
'day' => new xmlrpcval($day,'int'),
'hour' => new xmlrpcval($hour,'int'),
'min' => new xmlrpcval($minute,'int')),'struct'
);
$msg = new xmlrpcmsg('LJ.XMLRPC.postevent');
$msg->addparam($params);
$client->setDebug(0);
$result = $client->send($msg);
}`
А что-бы не появилось ошибок типа
**Application failed during request deserialization** проверьте кодировку в библиотеке — наверняка пытается utf отослать как iso.
… так почему на habrahabr нет XML-RPC? | https://habr.com/ru/post/12217/ | null | ru | null |
# Разработка OS на Go+asm Part 0x00
Доброго времени суток %username%.
Захотелось мне пописать что-то ненормальное. Выбор пал на ОС, в конце-концов каждый программист должен написать свою ОС, пусть хотя бы учебную.
Как некоторым известно, я очень люблю язык Go ну, и решил попробовать написать на нем. Что из этого получилось — под хабракатом.
Part 0x00
[Part 0x01](http://habrahabr.ru/post/259839/)
Step 0x00
=========
Писать свой загрузчик я не буду, не для того умные люди придумывали спеку multiboot.
Для начала напишем код первоначальной загрузки (файл multiboot.s)
```
MBOOT_PAGE_ALIGN equ 1<<0
MBOOT_MEM_INFO equ 1<<1
MBOOT_HEADER_MAGIC equ 0x1BADB002
MBOOT_HEADER_FLAGS equ MBOOT_PAGE_ALIGN | MBOOT_MEM_INFO
MBOOT_CHECKSUM equ -(MBOOT_HEADER_MAGIC + MBOOT_HEADER_FLAGS)
[BITS 32]
[GLOBAL mboot]
[EXTERN code]
[EXTERN bss]
[EXTERN end]
mboot:
dd MBOOT_HEADER_MAGIC
dd MBOOT_HEADER_FLAGS
dd MBOOT_CHECKSUM
dd mboot
dd code
dd bss
dd end
dd start
[GLOBAL start]
extern go.kernel.Load ;Указываем на то, что у нас есть внешняя функция на Go
start:
push ebx
cli
call go.kernel.Load ;Вызываем внешнюю функцию, которая содержит основной код ядра
jmp $
```
теперь создадим файл kernel.go следующего содержания:
```
package kernel
func Load(){
//Как видим наше ядро пока ничего не делает
}
```
Создадим файл link.ld
```
ENTRY(start)
SECTIONS
{
.text 0x100000 :
{
code = .; _code = .; __code = .;
*(.text)
. = ALIGN(4096);
}
.data :
{
data = .; _data = .; __data = .;
*(.data)
*(.rodata)
. = ALIGN(4096);
}
.bss :
{
bss = .; _bss = .; __bss = .;
*(.bss)
. = ALIGN(4096);
}
end = .; _end = .; __end = .;
}
```
и Makefile
```
SOURCES=multiboot.o kernel.go.o
GOFLAGS= -nostdlib -nostdinc -fno-stack-protector -fno-split-stack -static -m32 -g -I.
GO=gccgo
ASFLAGS= -felf
NASM= nasm $(ASFLAGS)
OBJCOPY=objcopy
LDFLAGS=-T link.ld -m elf_i386
all: $(SOURCES) link
clean:
rm *.o kernel
link:
ld $(LDFLAGS) -o kernel $(SOURCES)
%.go.o: %.go
$(GO) $(GOFLAGS) -o $@ -c $<
%.o: %.s
$(NASM) $<
```
Теперь, выполнив make в дирректории проекта вы получите на выходе файл kernel, который можно загрузить с помощью qemu:
**qemu-system-i386 -kernel ./kernel**
Ядро успешно загрузится и ничего не будет делать )
Step 0x01
=========
Настало время поздороваться с миром.
Для начала добавим в multiboot.s следующие строки:
```
global __go_runtime_error
global __go_register_gc_roots
global __unsafe_get_addr
__unsafe_get_addr:
push ebp
mov ebp, esp
mov eax, [ebp+8]
mov esp, ebp
pop ebp
ret
__go_register_gc_roots:
__go_runtime_error:
ret
```
функция \_\_unsafe\_get\_addr нужна для того, что бы мы могли конвертировать uint32 в указатели внутри Go
Другие две функции — просто затычки для компилятора
Теперь создадим файл screen.go
```
package screen
var (
frameBuffer *[totalMax]uint16 //Старшие 8 бит - символ, младшие - его атрибуты
cursorX, cursorY uint8
)
const (
frameBufferAddr = 0xB8000
maxX = 80
maxY = 25
totalMax = maxX * maxY
whiteOnBlack = 0x07
)
//Ниже мы создаем обертку для Go над нашей функцией __unsafe_get_addr
//extern __unsafe_get_addr
func getAddr(addr uint32) *[totalMax]uint16
func Init() {
cursorX = 0
cursorY = 0
frameBuffer = getAddr(frameBufferAddr) //Получаем доступ к видеобуферу
}
//Очистка экрана, просто заполняем весь видеобуфер нулями
func Clear() {
for i := 0; i < totalMax; i++ {
frameBuffer[i] = 0
}
cursorX = 0
cursorY = 0
}
//Меняем позицию курсора
func SetCursor(x, y uint8) {
cursorX = x
cursorY = y
}
//Скроллим экран если он заполнен
func scroll() {
if cursorY >= maxY {
for i := 0; i < 24*maxX; i++ {
frameBuffer[i] = frameBuffer[i+80] //Смещаем все строки на одну вверх
}
for i := 24 * 80; i < totalMax; i++ {
//Очищаем нижнюю строку
frameBuffer[i] = 0x20 | (((0 << 4) | (15 & 0x0F)) << 8)
frameBuffer[i] = 0
}
cursorY = 24
cursorX = 0
}
}
//Вывод символов
func putChar(c byte) {
switch c {
case 0x08: //backspace
if cursorX > 0 {
cursorX--
}
case 0x09: //tab
cursorX = (cursorX + 8) & (8 - 1)
case '\r': //return
cursorX = 0
case '\n': //new line
cursorX = 0
cursorY++
default:
if c >= 0x20 { //Все печатные символы
frameBuffer[cursorY*80+cursorX] = uint16(c) | (((0 << 4) | (15 & 0x0F)) << 8)
cursorX++
}
}
if cursorX >= 80 { //Если надо перемещаем курсор
cursorX = 0
cursorY++
}
scroll()
}
//Выводим строку
func PrintStr(s string) {
for i := 0; i < len(s); i++ {
putChar(s[i])
}
}
```
Теперь надо подключить наш модуль screen к ядру — в kernel.go добавляем import «screen», там же, в функци Load() пишем:
```
screen.Init()
screen.Clear()
screen.PrintStr("Hello Habrahar!")
```
Теперь надо указать компилятору как все это дело собирать нам понадобится добавить в Makefile следующие строки:
```
%.gox: %.go.o
$(OBJCOPY) -j .go_export $< $@
```
И там же, в переменную SOURCES между multiboot.o и kernel.go.o добавить screen.go.o и screen.gox
После проведения всех манипуляций вызываем команду make и запускаем qemu с нашим ядром. Дожидаемся загрузки и радуемся
P.S. Прошу простить меня за опечатки, если они есть. Обязуюсь исправить.
~~P.P.S. На днях код будет выложен на github~~
[github.com/t0pep0/Daria/tree/Part0x00](https://github.com/t0pep0/Daria/tree/Part0x00)
\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_
Обсуждение на osdev.ru:
<http://osdev.ru/viewtopic.php?f=4&t=1100>
Чат в слаке (в golang-ru):
<https://golang-ru.slack.com/messages/daria/> | https://habr.com/ru/post/259719/ | null | ru | null |
# 3D-графика в Go
В большинстве случаев, когда речь заходит об использовании Go, вспоминается backend или DevOps и в самую последнюю очередь можно подумать об использовании Go для создания [мобильных](https://habr.com/ru/company/otus/blog/698140/) или [десктопных](https://habr.com/ru/company/otus/blog/699096/) приложений. Но в действительности, благодаря возможностям интеграции с нативными библиотеками (в том числе, OpenGL и OpenAL для пространственного звука) Go может использоваться и для создания игр (в том числе для мобильной платформы). В этой статье мы обсудим несколько библиотек, которые могут помочь в создании 3D-графики на Go и обсудим вопросы портирования приложений на мобильные платформы.
Любая 3D-игра или приложение с трехмерной визуализацией использует возможности, предоставляемые системными библиотеками для работы с графическим адаптером, который переводит команды из абстрактного API (например, OpenGL или Angle) в концепции, понятные графическому ускорителю (или эмулирует их программно на обычном процессоре). Библиотеки OpenGL основаны на использовании шейдеров — приложений на специальном языке GLSL (OpenGL Shading Language), которые выполняются непосредственно на графическом ускорителе. 3D-графика в OpenGL опирается на два или более шейдера (как минимум должен быть определен вершинный шейдер, который обеспечивает трансформацию 3D-координат в проекцию на экране с учетом матричных преобразований для камеры перспективы, расположения и ориентировки объекта и наблюдателя) и фрагментный шейдер (который обеспечивает вычисление или интерполяцию цвета каждой точки сцены с учетом освещения, теней, отражений и другого). В действительности, разработка на таком низком уровне требуется редко (и доступна, например, в GoMobile, когда мы должны определить код шейдеров самостоятельно) и обычно используются один из 3D-движков, которые скрывают всю сложность за простыми понятиями сцены:
* камера (расположение наблюдателя, линии взгляда и ориентировки сцены, например "направление вверх")
* источники света (фоновое освещение, всенаправленные, точечные источники или прожекторы)
* объекты сцены (представляются в виде 3d mesh, составленной из треугольников или многоугольников)
Также с объектами может быть связано описание движения и способа взаимодействия с другими объектами при столкновении, свойства материала для отображения поверхности (в частности, диффузный цвет, отражающая способность и цвет, соотношение диффузного и зеркального отражения, которая определяет насколько матовой или глянцевой является поверхности), текстура материала и многое другое.
Для разработки 3D-визуализаций на Go (для desktop) можно использовать одну из следующих библиотек: Azul3D, Harfang3D и G3N:
### Azul3D
[Azul3D](https://azul3d.org/) — довольно старый 3D-движок на OpenGL 2, который поддерживает создание визуализаций, трехмерный звук (через OpenAL), физические симуляции (в 2D через chipmunk и в 3D в Open Dynamics Engine ODE). Для реализации 3D-графики нужно самостоятельно определить шейдеры (файлы .vert и .frag), но при этом библиотека дает возможность вычисления необходимых матриц (например, камеры), определения Mesh. Для использования доступны следующие модули:
* `azul3d.org/engine/gfx/window` — контекст отображения 3D-графики с поддержкой eventloop для обработки событий клавиатуры и мыши. Для запуска EventLoop используется функция `window.Run(gfxLoop, nil)`. Для получения ожидающих обработки событий нужно использовать `window.Poll`, который принимает канал с событиями и функцию для обработки `window.Event`, которая может быть либо событием самого окна (например, window.FramebufferResized), нажатием клавиш (`keyboard.Typed`) и др. Также можно получать текущее состояние клавиатуры `Keyboard()` и мыши `Mouse()`.
* `azul3d.org/engine/keyboard` — обработка событий нажатия/отпускания клавиш
* `azul3d.org/engine/mouse` — обработка событий мыши
* `azul3d.org/engine/gfx` — непосредственно структуры для определения графики и загрузки шейдеров. `gfx.Device` определяет связь с виртуальным графическим адаптером, через который можно получать информацию об области отображения — `Bounds()`, отображать объекты сцены `Draw(bounds, object, cam)`, управлять настройками OpenGL (например, включать Multisample Anti-Aliasing MSAA) и выполнять отрисовку сцены `Render()`. Также через gfx можно создавать объекты сцены `gfx.NewObject()`, определять mesh `gfx.NewMesh()`, цвета `gfx.Color`, трансформации `gfx.NewTransform()`. К объекту сцены присоединяется Mesh, Shader для визуализации (могут быть загружены через `gfxutil.LoadShader()` из azul3d.org/engine/gfx/gfxutil).
Пример кода для построения простого треугольника с возможностью управления через клавиатуры можно посмотреть [здесь](https://github.com/azul3d/examples/blob/master/azul3d_triangle/azul3d_triangle.go).
### Harfang 3D
[Harfang3D](https://github.com/harfang3d/harfang3d) — библиотека для использования 3D-графики, совместимая с OpenGL, OpenGL ES (в том числе, Android), Metal, Vulkan, DirectX, также поддерживает API для систем виртуальной реальности (SteamVR c отслеживанием глаз, Oculus Rift, HTC Vive), физическое моделирование (столкновения, механические ограничения), трехмерный звук. Сама библиотека создана на C++, но есть поддержка интеграций с Python, Lua и Go. Использует модель описания сцены через добавление компонентов, которыми могут быть как mesh-объекты, так и источники света и др. При сборке SDK нужно указать -DHG\_BUILD\_HG\_GO=ON (для компиляции Go-связывания).
Модуль импортируется из `"github.com/harfang3d/harfang-go/v3"` и предоставляет возможность загрузки asset'ов и сцены, манипуляции узлами, создания преднастроенных mesh (например, `CreateSphereModel` или `CreateCubeModel`), источников света (`CreateSpotLight`), камеры (`CreateCamera`), создания матриц и выполнения преобразований (например, `TransformationMat4`), реализации eventloop для реакции на действия пользователя. Пример кода для визуализации сцены:
```
import (
math
hg "github.com/harfang3d/harfang-go/v3"
)
func main() {
hg.InputInit()
hg.WindowSystemInit()
//подготовка окна для рисования
var resX int32 = 1280
var resY int32 = 720
win := hg.RenderInitWithWindowTitleWidthHeightResetFlags("Harfang Sample", resX, resY, hg.RFMSAA4X)
pipeline := hg.CreateForwardPipelineWithShadowMapResolution(4096)
//создание конвейера отрисовки
res := hg.NewPipelineResources()
vtxLayout := hg.VertexLayoutPosFloatNormUInt8()
sphereMdl := hg.CreateSphereModel(vtxLayout, 0.1, 8, 16)
sphereRef := res.AddModel("sphere", sphereMdl)
//будем использовать предкомпилированные шейдеры
shader := hg.LoadPipelineProgramRefFromFile("resources_compiled/core/shader/default.hps", res, hg.GetForwardPipelineInfo())
//определение материала (для цвета задается RGB от 0 до 1)
sphereMat := hg.CreateMaterialWithValueName0Value0ValueName1Value1(shader, "uDiffuseColor", hg.NewVec4WithXYZ(1, 0, 0), "uSpecularColor", hg.NewVec4WithXYZ(1, 0.8, 0))
//создания.и конфигурация фонового цвета
scene := hg.NewScene()
scene.GetCanvas().SetColor(hg.NewColorWithRGB(0.1, 0.1, 0.1))
scene.GetEnvironment().SetAmbient(hg.NewColorWithRGB(0.1, 0.1, 0.1))
//установка камеры
cam := hg.CreateCamera(scene, hg.TransformationMat4(hg.NewVec3WithXYZ(15.5, 5, -6), hg.NewVec3WithXYZ(0.4, -1.2, 0)), 0.01, 100)
scene.SetCurrentCamera(cam)
//добавление света
hg.CreateSpotLightWithDiffuseDiffuseIntensitySpecularSpecularIntensityPriorityShadowTypeShadowBias(scene, hg.TransformationMat4(hg.NewVec3WithXYZ(-8.8, 21.7, -8.8), hg.Deg3(60, 45, 0)), 0, hg.Deg(5), hg.Deg(30), hg.ColorGetWhite(), 1, hg.ColorGetWhite(), 1, 0, hg.LSTMap, 0.000005)
//создаем объекты сцены (сферы)
rows := [][]*hg.Transform{}
for z := float32(-100.0); z < 100.0; z += 2.0 {
row := []*hg.Transform{}
for x := float32(-100.0); x < 100.0; x += 2.0 {
node := hg.CreateObjectWithSliceOfMaterials(scene, hg.TranslationMat4(hg.NewVec3WithXYZ(x*0.1, 0.1, z*0.1)), sphereRef, hg.GoSliceOfMaterial{sphereMat})
row = append(row, node.GetTransform())
}
rows = append(rows, row)
}
angle := 0.0
rect := hg.NewIntRectWithSxSyExEy(0, 0, resX, resY)
//основной цикл
for !hg.ReadKeyboard().Key(hg.KEscape) && hg.IsWindowOpen(win) {
dt := hg.TickClock()
angle += float64(hg.TimeToSecF(dt))
//поворот объектов сцены (узлов) на угол
for j, row := range rows {
rowY := math.Cos(angle + float64(j)*0.1)
for i, trs := range row {
/*pos := trs.GetPos()
pos.SetY(float32(0.1 * (rowY*math.Sin(angle+float64(i)*0.1)*6 + 6.5)))
trs.SetPos(pos)
*/
p := hg.NewVec3()
p, _ = trs.GetPosRot()
p.SetY(float32(0.1 * (rowY*math.Sin(angle+float64(i)*0.1)*6 + 6.5)))
trs.SetPos(p)
}
}
//обновление сцены
scene.Update(dt)
viewID := uint16(0)
//отправка сцены в pipeline
hg.SubmitSceneToPipelineWithFovAxisIsHorizontal(&viewID, scene, rect, true, pipeline, res)
//обновление экрана из буфера
hg.Frame()
hg.UpdateWindow(win)
runtime.GC()
}
hg.RenderShutdown()
hg.DestroyWindow(win)
}
```
Для подготовки ресурсов используются конверторы из 3D-форматов (включая Autodesk FBX) и компиляторы ресурсов (assetc, может быть загружен [отсюда](https://dev.harfang3d.com/releases/3.2.5/)). Для определения шейдеров используется собственный язык, во многом совместимый с GLSL (за исключением нескольких важных [отличий](https://dev.harfang3d.com/docs/3.2.5/man.shader/)).
### G3N
Движок G3N написан полностью на Go и использует библиотеки OpenGL для Windows / Linux и MacOS. Также дополнительно поддерживается пространственный звук через OpenAL. Сцена описывается иерархическим графом из узлов (при этом трансформации узла применяются ко всему поддереву, что позволяет создавать сложные анимации сцены). Поддерживается загрузка 3D-моделей в формате obj (Wavefront) и glTF, а также генерация объектов (сфера, цилиндр, куб и другие), вывод текста и анимированных спрайтов (из spritesheet). Также могут использоваться преднастроенные или собственные материалы, загрузка текстур из PNG/JPEG файлов, добавление источников света (точечных и направленных). Доступна возможность определения собственных шейдеров (вершинных, фрагментных и геометрических). Также предоставляется модуль для создания пользовательских интерфейсов из готовых (или созданных программно) виджетов. В библиотеке доступны следующие модули:
* `github.com/g3n/engine/animation` — определение анимации свойств узла (рассчитывает tween-значения для канала, который определяет тип интерполяции и изменяемое значение — положение, поворот, масштаб или морфинг между объектами)
* `github.com/g3n/engine/app` — определение приложения (App), которое предоставляет доступ к событиям жизненного цикла (`Subscribe`) и изменений в области отображения (например, `window.OnWindowSize`) и позволяет запустить eventloop через `App().Run(…)`. Также через функцию `Gls()` в `App()` можно непосредственно вызывать функции OpenGL (например, Clear для очистки сцены)
* `github.com/g3n/engine/audio` — поддержка воспроизведения и 3D-позиционирования звука (через OpenAL), плеер создается через `audio.NewPlayer` из файла (Ogg Vorbis или WAV)
* `github.com/g3n/engine/camera` — определение камеры (положения, направление взгляда и ориентация сцены), также можно присоединить управляемую камеру (`camera.NewOrbitControl`)
* `github.com/g3n/engine/core` — основные абстракции сцены: `core.NewNode()` создает новый узел, в который могут быть добавлены новые узлы (например, Mesh, UI-виджет или источник света)
* `github.com/g3n/engine/geometry` — создание геометрических фигур (например, `geometry.NewTorus` или `geometry.NewSphere`)
* `github.com/g3n/engine/gls` — константы и функции OpenGL для использования совместно с `App().Gls()`
* `github.com/g3n/engine/graphic` — создание Mesh для добавления на сцену `graphic.NewMesh(geom, mat)`.
* `github.com/g3n/engine/gui` — создание UI (например, `gui.NewButton` для определения кнопки)
* `github.com/g3n/engine/light` — создание источников света (`NewAmbient` для фонового освещения, `NewPoint` — точечный источник, `NewDirectional` — направленный источник, `NewSpot` — всенаправленный источник). Для каждого источника можно задать цвет, светимость и свойства затухания (а для направленных — еще и основное направление).
* `github.com/g3n/engine/loader` — загрузка модели из Wavefront / glTF или Collada. Например, для загрузки объекта из Wavefront можно использовать loader/obj `obj.Decode(objpath, mtlpath).NewGroup()` возвращает core.Node для добавления в сцену
* `github.com/g3n/engine/material` — определение материала из комбинации диффузного и зеркального рассеивания, прозрачности и текстуры.
* `github.com/g3n/engine/math32` — содержит константы (например, Pi), цвета (преднастроенные и определяемые программно) и математические функции (совместимые с OpenGL)
* `github.com/g3n/engine/renderer` — выполняет отрисовку сцены `renderer.Render(scene, cam)` для указанной камеры
* `github.com/g3n/engine/text` — отображение текста (загрузка шрифтов, генерация atlas для дальнейшего отображения на сцене)
* `github.com/g3n/engine/texture` — определение текстур (Texture2D) и загрузчиков `texture.NewTexture2DFromImage(filename)`, также позволяет создавать текстуру программно.
* `github.com/g3n/engine/util/helper` — создание вспомогательных узлов (например отображение осей)
* `github.com/g3n/engine/window` — константы и функции для работы с viewport и подписки на события окна.
Пример кода на G3N:
```
package main
import (
"github.com/g3n/engine/app"
"github.com/g3n/engine/camera"
"github.com/g3n/engine/core"
"github.com/g3n/engine/geometry"
"github.com/g3n/engine/gls"
"github.com/g3n/engine/graphic"
"github.com/g3n/engine/light"
"github.com/g3n/engine/material"
"github.com/g3n/engine/math32"
"github.com/g3n/engine/renderer"
"time"
)
func main() {
//приложение и сцена
a := app.App()
scene := core.NewNode()
//создание управляемой камеры
cam := camera.New(1)
cam.SetPosition(0, 0, 3)
scene.Add(cam)
camera.NewOrbitControl(cam)
//создание фигуры
geom := geometry.NewTorus(1, .4, 12, 32, math32.Pi*2)
mat := material.NewStandard(math32.NewColor("DarkGreen"))
mesh := graphic.NewMesh(geom, mat)
scene.Add(mesh)
//создание освещения (фонового и точечного)
scene.Add(light.NewAmbient(&math32.Color{1.0, 1.0, 1.0}, 0.8))
pointLight := light.NewPoint(&math32.Color{1, 1, 0}, 5.0)
pointLight.SetPosition(1, 0, 2)
scene.Add(pointLight)
//изменение фона в OpenGL
a.Gls().ClearColor(0.5, 0.5, 0.5, 1.0)
//запуск приложения и отрисовка кадра
a.Run(func(renderer *renderer.Renderer, deltaTime time.Duration) {
a.Gls().Clear(gls.DEPTH_BUFFER_BIT | gls.STENCIL_BUFFER_BIT | gls.COLOR_BUFFER_BIT)
renderer.Render(scene, cam)
})
}
```
Из рассмотренных библиотек для использования на мобильной платформе наиболее подходящей является Harfang 3D, поскольку она поддерживает взаимодействие с OpenGL ES и может быть собрана через gomobile для создания мобильного приложения. Однако сейчас эта возможность еще находится в стадии эксперимента и работает нестабильно. Но при этом создание 3D-визуализаций на Go для desktop-приложений доступно уже сейчас.
---
В январе состоится открытый вебинар онлайн-курса "Golang Developer. Professional", на котором руководитель курса проведет Mock-собеседование со студентом. Участники рассмотрят реальные вопросы, разберут комментарии по ответам; спикер поделится советами по прохождению собеседований. Если для кого-то актуально, зарегистрироваться на вебинар можно [по ссылке](https://otus.pw/NAOc/). | https://habr.com/ru/post/708170/ | null | ru | null |
# Типичные ошибки начинающих работать с изображениями
Цифровая обработка изображений — весьма интересная область, но она таит в себе множество подводных камней, на которые постоянно натыкаются новички. Мы активно привлекаем студентов к участию в грантах и проектах, но когда мы пытались давать студентам реальные задания, которые требуют реализации новых алгоритмов обработки изображений, мы были в ужасе от совершаемых ими детских ошибок.
Поэтому перед постановкой полноценных задач мы стали давать студентам ряд практических заданий по реализации стандартных алгоритмов обработки изображений: базовые операции над изображениями (поворот, размытие), свёртка, интерполяция с помощью простых фильтров (билинейная, бикубическая), направленная интерполяция, выделение границ с помощью алгоритма Канни, детектирование ключевых точек и т.д. Язык программирования мог быть любым, однако при выполнении заданий не допускается использование сторонних библиотек, за исключением чтения и записи изображений. Это связано с тем, что задания носят обучающий характер, самостоятельная реализация алгоритмов является хорошей практикой в программировании и позволяет понять, как работают методы изнутри.
Данная статья описывает наиболее частые ошибки, совершаемые студентами при выполнении практических заданий по обработке изображений. Изображения обычные, никакой экзотики типа 16-битной глубины цвета, панхроматичности и 3D-изображений нет.
Ошибка 1. Работа с пикселями, используя системные объекты Bitmap, HBITMAP и им подобные для хранения изображений
----------------------------------------------------------------------------------------------------------------
Данные объекты предназначены для взаимодействия с графической подсистемой (рисование примитивов и текста, вывод на экран) и не предоставляют возможности прямого доступа к участку памяти, в котором хранятся пиксели изображения. Доступ к пикселям осуществляется с помощью функций GetPixel и SetPixel. Вызов этих функций очень дорогой — на два-три порядка медленнее, чем прямой доступ к пикселям. Особенно велик соблазн так делать в C#, где тип Bitmap доступен «из коробки».
**Решение:** использовать данные классы только для чтения из файла, записи в файл и вывод на экран, в остальных случаях работать с классами, имеющими эффективный доступ к пикселям.
**Замечание:** в некоторых случаях в Windows удобно работать с DIB (device independent bitmap): есть и прямой доступ к пикселям, и возможность вывода на экран, минус — ограничение на тип пикселя.
Ошибка 2. Использование библиотек для работы с изображениями при отсутствии опыта обработки изображений
-------------------------------------------------------------------------------------------------------
Использование библиотек чревато непониманием работы алгоритмов и дальнейшими трудностями при решении практических задач, требующих разработки собственных алгоритмов, которых нет в библиотеках. Я сталкивался с хорошо программирующими студентами, которые не могли реализовать даже элементарные операции типа свёртки: то не получалось подключить библиотеку, то работало не так, но на написание функции из 10 строчек ума уже не хватало.
**Решение:** не использовать сторонние библиотеки, а писать свои классы для работы с изображениями и самостоятельно реализовывать основные алгоритмы. Особенно полезно это для тех, кто не имеет достаточного опыта программирования. Лучше несколько раз сломать велосипед, чем завалить целый проект из-за глупых ошибок.
Ошибка 3. Потеря в точности при округлении
------------------------------------------
В результате применения различных алгоритмов обработки изображений возникают промежуточные результаты, имеющие вещественный тип. Пример: практически любой усредняющий фильтр, например, фильтр Гаусса. Приведение результатов к типу byte приводит к внесению дополнительной ошибки и менее точной работе алгоритмов.
Ниже приведён пример работы алгоритма детектировании контуров Канни, одним из составных частей которого является вычисление модуля градиента. Слева — модуль градиента после вычисления хранится в типе float, справа — округляется до byte.
 
Несложно заметить, что при округлении контуры становятся рваными.
**Решение:** если для алгоритма критична точность, то используйте тип float вместо byte для хранения значений пикселей, не занимайтесь преждевременной оптимизацией — сначала добейтесь нормальной работы алгоритма на float, а затем уже думайте, где можно использовать byte так, чтобы не снизилось качество.
**Замечание:** скорость работы современных процессоров с вещественными числами сопоставима с целыми. В некоторых случаях компилятор может применить автоматическую векторизацию, что приведёт к более быстрому коду с float. Также код с float может получиться более быстрым при большом количестве преобразований byte-float, округлений и отсечений. А вот использование double редко бывает оправдано, а мешанина из float и double так вообще является следствием непонимания типов и принципов работы с ними.
Использование целочисленных типов (byte, int16, uint16) особенно эффективно при использовании векторных операций, когда скорость доступа к памяти становится узким местом.
Ошибка 4. Выход значений пикселей за пределы диапазона [0, 255]
---------------------------------------------------------------
У вас нет проблем с точностью и вы всё ещё хотите для хранения значений пикселей использовать тип byte? Тогда возникает ещё одна проблема: многие операции, например бикубическая интерполяция или повышение резкости, приводят к появлению значений, выходящих за пределы указанного диапазона. Если не учитывать этот факт, то возникает эффект, называемый wrapping: значение 260 превращается в 4, а –3 — в 253. Появляются яркие точки и линии на тёмном фоне и тёмные — на светлом (слева — правильная реализация, справа — с ошибкой).
 
**Решение:** при выполнении промежуточных операций проверяйте на каждом шаге диапазон возможных значений, а при преобразовании в байтовый тип обязательна проверка на выход за границы диапазона, например, так:
```
unsigned char clamp(float x)
{
return x < 0.0f ? 0 : (x > 255.0f ? 255 : (unsigned char)x);
}
```
Ошибка 5. Потеря значений в результате приведения к диапазону [0, 255]
----------------------------------------------------------------------
Вы предпочитаете работать с типом byte и используете функцию `clamp`? А вы уверены, что ничего не теряете, как в случае с округлением?
Видел на практике, как студенты при вычислении производной или при применении фильтра Собеля таким образом теряли отрицательные значения.
**Решение:** используйте типы достаточного размера для хранения промежуточных результатов, а функцию clamp только для сохранения в файл или вывода на экран. Для визуализации производной добавляйте 128 к значению пикселя, либо берите модуль.
Ошибка 6. Неправильный порядок обхода по пикселям изображения, приводящий к замедлению работы программы
-------------------------------------------------------------------------------------------------------
Память в компьютере одномерна. Двумерные изображения хранятся в памяти в виде одномерных массивов. Обычно они записываются построчно: сначала идёт 0-я строка, затем 1-я и т.д.
Последовательный доступ к памяти осуществляется быстрее, чем произвольный. Это связано с работой кэша процессора, который помещает данные из памяти в кэш большими блоками, например, по 64 байта для современных процессоров. В этот блок попадают сразу несколько соседних по горизонтали пикселей. Значит, при обращении к последующим пикселям в той же строке скорость доступа будет выше, чем к последующим пикселям в столбце.
**Решение:** Обход по изображению нужно делать так, чтобы доступ к памяти был последовательный: во внешнем цикле производится обход по вертикали, а во внутреннем — по горизонтали:
```
for (int y = 0; y < image.Height(); y++)
for (int x = 0; x < image.Width(); x++)
...
```
**Примечание:** В разных языках способ представления многомерных массивов в памяти может быть различным. [Имейте это в виду.](http://eli.thegreenplace.net/2015/memory-layout-of-multi-dimensional-arrays)
Ошибка 7. Путаница с шириной и высотой
--------------------------------------
Классическая проблема: тестирование либо отсутствует, либо осуществляется только на квадратных изображениях, в полевых условиях при работе с прямоугольными изображениями происходит выход за границу массива.
**Решение:** не забывайте про тестирование! Спор о TDD предлагаю не разводить: его использование — это личное дело каждого.
Ошибка 8. Отказ от абстракций
-----------------------------
Боязнь плодить сущности — типичная ошибка новичков, она приводит к проблемам с читаемостью и восприятием кода. Здесь можно привести много примеров.
1. Обращение к пикселям через непосредственное вычисление индексов в массиве вместо использования методов `getPixel(x, y)` и `setPixel(x, y)`. Помимо удобства, в этих методах можно проверять и корректно обрабатывать выход за границы изображения. Например, не выдавать ошибку, а эктраполировать значения изображения.
**Просто посмотрите на этот прекрасный код (в коде, кстати, есть ошибка, и не одна)**
```
b1 = (float)0.25 * ( w1 - 1) * (w1 - 2) * (w1 + 1) * (h1 - 1) * (h1 - 2) * (h1 + 1);
b2 = -(float)0.25 * w1 * (w1 + 1) * (w1 - 2) * (h1 - 1) * (h1 - 2) * (h1 + 1);
b3 = -(float)0.25 * (w1 - 1) * (w1 - 2) * (w1 + 1) * (h1 + 1) * (h1 - 2);
b4 = (float)0.25 * w1 * h1 * (w1 + 1) * (w1 - 2) * (h1 + 1) * (h1 - 2);
b5 = -(1 / 12) * w1 * (w1 - 1) * (w1 - 2) * (h1 - 1) * (h1 - 2) * (h1 + 1);
b6 = -(1 / 12) * h1 * (w1- 1) * (w1 - 2) * (w1 + 1) * (h1 - 1) * (h1 - 2);
b7 = (1 / 12) * w1 * h1 * (w1 + 1) * (w1 - 2) * (h1 + 1) * (h1 - 2);
b8 = (1 / 12) * w1 * h1 * (w1- 1) * (w1 - 2) * (h1 - 1) *( h1 - 2);
b9 = (1 / 12) * w1 * (w1 - 1) * (w1 + 1) * (h1 - 1) * (h1 - 2) * (h1 + 1);
b10 = (1 / 12) * w1 * (w1 - 1) * (w1 - 2) * (w1 + 1) * (h1 - 1) * (h1+ 1);
b11 = (1 / 36) * w1 * h1 * (w1 - 1) * (w1 - 2) * (w1 - 1) * (h1 - 2) * (h1- 2);
b12 = -(1 / 12) * w1 * h1 * (w1 - 1) * (w1 + 1) * (h1 + 1) * (h1 - 2);
b13 = -(1 / 12) * w1 * h1 * (w1 + 1) * (w1 - 2) * (h1 - 1) * (h1 + 1);
b14 = -(1 / 36) * w1 * (w1 - 1) * (w1 + 1) * (h1 - 1) * (h1 - 2);
b15 = -(1 / 36) * w1 * h1 * (w1 - 1) * (w1 - 2) * (h1 - 1) * (h1 + 1);
b16 = (1 / 36) * w1 * h1 * (w1 - 1) * (w1 + 1) * (h1 - 1) * (h1 + 1);
image2.rawdata[y1 * image2.Width + x1].b =
image1.rawdata[h * image1.Width + w].b * b1
+ image1.rawdata[h * image1.Width + w + 1].b * b2
+ image1.rawdata[(h + 1) * image1.Width + w].b * b3
+ image1.rawdata[(h + 1) * image1.Width + w + 1].b * b4
+ image1.rawdata[h * image1.Width + w - 1].b * b5
+ image1.rawdata[(h - 1) * image1.Width + w].b * b6
+ image1.rawdata[(h + 1) * image1.Width + w - 1].b * b7
+ image1.rawdata[(h - 1) * image1.Width + w + 1].b * b8
+ image1.rawdata[h * image.Width + w + 2].b * b9
+ image1.rawdata[(h + 2) * image1.Width + w].b * b10
+ image1.rawdata[(h - 1) * image1.Width + w - 1].b * b11
+ image1.rawdata[(h + 1) * image1.Width + w + 2].b * b12
+ image1.rawdata[(h + 2) * image1.Width + w + 1].b * b13
+ image1.rawdata[(h - 1) * image1.Width + w + 2].b * b14
+ image1.rawdata[(h + 2) * image1.Width + w - 1].b * b15
+ image1.rawdata[(h + 2) * image1.Width + w + 2].b * b16;
image2.rawdata[y1 * image2.Width + x1].g =
image1.rawdata[h * image1.Width + w].g * b1
+ image1.rawdata[h * image1.Width + w + 1].g * b2
+ image1.rawdata[(h + 1) * image1.Width + w].g * b3
+ image1.rawdata[(h + 1) * image1.Width + w + 1].g * b4
+ image1.rawdata[h * image1.Width + w - 1].g * b5
+ image1.rawdata[(h - 1) * image1.Width + w].g * b6
+ image1.rawdata[(h + 1) * image1.Width + w - 1].g * b7
+ image1.rawdata[(h - 1) * image1.Width + w + 1].g * b8
+ image1.rawdata[h * image1.Width + w + 2].g * b9
+ image1.rawdata[(h + 2) * image1.Width + w].g * b10
+ image1.rawdata[(h - 1) * image1.Width + w - 1].g * b11
+ image1.rawdata[(h + 1) * image1.Width + w + 2].g * b12
+ image1.rawdata[(h + 2) * image1.Width + w + 1].g * b13
+ image1.rawdata[(h - 1) * image1.Width + w + 2].g * b14
+ image1.rawdata[(h + 2) * image1.Width + w - 1].g * b15
+ image1.rawdata[(h + 2) * image1.Width + w + 2].g * b16;
image2.rawdata[y1 * image2.Width + x1].r =
image1.rawdata[h * image1.Width + w].r * b1
+ image1.rawdata[h * image1.Width + w + 1].r * b2
+ image1.rawdata[(h + 1) * image1.Width + w].r * b3
+ image1.rawdata[(h + 1) * image1.Width + w + 1].r * b4
+ image1.rawdata[h * image1.Width + w - 1].r * b5
+ image1.rawdata[(h - 1) * image1.Width + w].r * b6
+ image1.rawdata[(h + 1) * image1.Width + w - 1].r * b7
+ image1.rawdata[(h - 1) * image1.Width + w + 1].r * b8
+ image1.rawdata[h * image1.Width + w + 2].r * b9
+ image1.rawdata[(h + 2) * image1.Width + w].r * b10
+ image1.rawdata[(h - 1) * image1.Width + w - 1].r * b11
+ image1.rawdata[(h + 1) * image1.Width + w + 2].r * b12
+ image1.rawdata[(h + 2) * image1.Width + w + 1].r * b13
+ image1.rawdata[(h - 1) * image1.Width + w + 2].r * b14
+ image1.rawdata[(h + 2) * image1.Width + w - 1].r * b15
+ image1.rawdata[(h + 2) * image1.Width + w + 2].r * b16;
```
Это реализация бикубической интерполяции в исполнении студента.
Лишь немногие студенты догадались, что бикубическая интерполяция сепарабельна, и сумели обойтись четырьмя коэффициентами вместо шестнадцати.
2. Дублирование кода при работе с цветными изображениями, приводящее к ошибкам (см. пример выше). Вместо copy-paste кода и замены `r` на `g` и на `b` достаточно было бы использовать перегрузку операторов. В три раза меньше кода, в три раза понятнее.
3. Использование двумерных массивов вместо создания отдельного класса для изображения.
Проблема заключается в том, что индексация получается неестественной — `(y, x)` вместо `(x, y)`, а размерности массива не очевидны: непонятно, что из `GetLength(0)` и `GetLength(1)` есть ширина, а что — высота. Высок риск просто перепутать индексы.
4. Использование трёхмерных массивов для хранения цветных изображений вместо создания отдельного класса для изображения. В дополнение к предыдущему пункту, приходится помнить, какой из индексов соответствует какой цветовой компоненте. Также видел, как трёхмерные массивы используются для хранения векторов, как в виде `(vx, vy)`, так и в виде `(v, angle)`. Запутаться легко.
5. Использование массива вместо класса. Угадайте, что возвращает следующая функция?
```
public static double[] HoughTransform2(GrayscaleFloatImage image, ref float[][] direction, ColorFloatImage cimage)
```
Ответ: массив из 11 элементов, каждый из элементов имеет свой сакральный смысл, непонятный без длительного анализа кода. Не делайте так! Заведите класс и назовите каждое из полей по-человечески.
6. Переиспользование переменных с изменением семантики. Видите в коде `gradx` и `grady` и думаете, что это призводные по `x` и по `y`? А вот и нет, это модуль и угол:
```
gradx[x, y] = (float)Math.Sqrt(temp1 * temp1 + temp2 * temp2);
grady[x, y] = (float)(Math.Abs(Math.Atan2(temp2, temp1)) * 180 / Math.PI);
```
**Решение:** никаких магических констант и индексов быть не должно. Оформляйте изображения как отдельные классы, сами пиксели тоже должны быть типизированы, а доступ к пикселям должен осуществляться только через специальные методы.
Ошибка 9. Применение некоторых математических функций неправильно или не к месту
--------------------------------------------------------------------------------
Здесь виной всему слабое понимание архитектуры процессора, набора инструкций и времени их выполнения. Простительно, приходит с опытом, но некоторые моменты я отмечу:
1. Возведение в квадрат в виде `Math.Pow(x, 2)` или `pow(x, 2)` вместо `x * x`.
Компиляторы не оптимизируют эти конструкции, вместо однотактового умножения они генерируют довольно сложный код, включающий в себя вычисление экспоненты и логарифма, что приводит к снижению скорости на порядок-два.
**Пояснение**Вызов `pow(x, y)` разворачивается в `exp(log(x) * y)`. Это занимает около 300 тактов при использовании команд x87. В SSE же экспоненты и логарифма до сих пор нет, существует множество реализаций `exp` и `log` с различной производительностью, например, [вот](https://github.com/herumi/fmath/blob/master/fastexp.cpp). В лучшем случае возведение в степень займёт 30-50 тактов. На умножение же уйдёт всего один такт.
2. Взятие целой части как `(int)Math.Floor((float)(j) / k)`, причём `k` — вещественное и не меняется внутри цикла.
Здесь достаточно было бы написать `(int)(j / k)`, а ещё лучше `(int)(j * inv_k)`, где `float inv_k = 1.0f / k`.
Дело в том, что floor возвращает вещественное число, которое затем нужно дополнительно преобразовывать в целое. Получается лишняя довольно дорогая операция. Ну а замена деления на умножение — просто оптимизация, операция деления до сих пор дорогая.
**Замечание**`(int)floor(x)` и `(int)x` зквивалентны только при неотрицательных x. Функция `floor` всегда округляет вниз, тогда как `(int)x` — в сторону нуля.
3. Вычисление обратного значения.
```
double _sum = pow(sum, -1);
```
Зачем так делать, когда можно написать `_sum = 1.0 / sum?`
**Решение:** применяйте математические функции только там, где они нужны.
Ошибка 10. Незнание языка
-------------------------
И опять проблемы с математикой:
1. Путаница с типами. Использование `long long` для индексов пикселей вместо `int`, постоянные преобразования между `float`, `double` и `int`. Например, зачем писать `(float)(1.0 / 16)`, когда можно написать `1.0f / 16.0f`?
2. Вычисление полярного угла через возню с `atan` и проблемой с делением на ноль вместо использования `atan2`, которая делает именно то, что надо.
3. Необычная экспонента и магические константы:
```
g=(float)Math.pow(2.71,-(d*d)/(2*sigma*sigma));
t=((float)1/((float)Math.sqrt(6.28)*sigma));
```
Здесь студент просто забыл про существование функции `exp` и константы `pi`. А вместо `(float)1` можно просто написать `1.0f`.
**Решение:** программируйте больше, только так вы наберётесь опыта.
Ошибка 11. Обфускация кода
--------------------------
Начинающие программисты любят показать своё мастерство, предпочитая писать короткий код, а не понятный.
1. Сложные циклы
```
for (int x1 = x - 1, x2 = 0; x1 <= x + 1; x1++, x2++)
{
for (int y1 = y - 1, y2 = 0; y1 <= y + 1; y1++, y2++)
{
```
Здесь правильно было бы сделать цикл от -1 до 1, а `x1` и `x2` вычислять уже внутри цикла, ну и порядок поменять:
```
for (int j = -1; j <= 1; j++)
{
int y1 = y + j, y2 = j + 1;
for (int i = -1; i <= 1; i++)
{
int x1 = x + i, x2 = i + 1;
```
Получилось бы даже быстрее за счёт того, что компиляторы легко оптимизируют простые циклы.
2. Крутые функции
```
long long ksize = llround(fma(ceil(3 * sigma), 2, 1)), rad = ksize >> 1;
```
А нормальные люди просто напишут
```
int rad = (int)(3.0f * sigma);
int ksize = 2 * rad + 1;
```
А это вообще за гранью добра и зла:
```
kernel[idx] = exp(ldexp(-pow(_sigma * (rad - idx), 2), -1));
```
Для тех, кто не понял: `ldexp(x, -1)` — это просто деление на 2.
**Решение:** просто помните, что рано или поздно вам отобьют пальцы молотком за такой код.
Ошибка 12. Порча значений обрабатываемых изображений
----------------------------------------------------
Вот кусок кода из подавления немаксимумов, являющегося частью алгоритма Канни:
```
for x in xrange(grad.shape[0]):
for y in xrange(grad.shape[1]):
if ((angle[x, y] == 0) and ((grad[x, y] <= grad[getinds(grad, x + 1, y)])
or (grad[x, y] <= grad[getinds(grad, x - 1, y)]))) or\
((angle[x, y] == 0.25) and ((grad[x, y] <= grad[getinds(grad, x + 1, y + 1)])
or (grad[x, y] <= grad[getinds(grad, x - 1, y - 1)]))) or\
((angle[x, y] == 0.5) and ((grad[x, y] <= grad[getinds(grad, x, y + 1)])
or (grad[x, y] <= grad[getinds(grad, x, y - 1)]))) or\
((angle[x, y] == 0.75) and ((grad[x, y] <= grad[getinds(grad, x + 1, y - 1)])
or (grad[x, y] <= grad[getinds(grad, x - 1, y + 1)]))):
grad[x, y] = 0
```
Здесь некоторые значения зануляются `grad[x, y] = 0`, а на последующих итерациях циклах к ним происходит обращение. Ошибка бы не произошла, если бы для вычисления промежуточного результата создавалось новое изображение, а не перезаписывалось текущее.
**Решение:** не стремитесь экономить память раньше времени, подумайте о функциональной парадигме.
Остальные ошибки
----------------
Остальные ошибки уже имеют непрограммистский характер. Это ошибки в реализации алгоритмов вследствие их непонимания, они индивидуальны. Например, неверный выбор размера ядра для фильтра Гаусса.
Фильтр Гаусса — один из основных фильтров в обработке изображений. Он лежит в основе огромного числа алгоритмов: детектирование контуров (edges) и хребтов (ridges), поиск ключевых точек, повышение резкости и т.д. Фильтр Гаусса имеет параметр «сигма», определяющий уровень размытия, его ядро описывается формулой:
а график имеет вид:
Данная функция нигде не обращается в ноль, а свёртка с ядром бесконечного размера не имеет смысла. Поэтому размер ядра выбирается таким, чтобы ошибка была ничтожно мала. Для практических задач достаточно взять ядро с радиусом `(int)(3 * sigma)` — ошибка будет меньше `1/1000`. Выбор слишком маленького ядра (красная функция на графике выше) приведёт к искажению фильтра Гаусса. Использование ядра фиксированного размера, например, 5х5 и приводит к некорректным результатам уже при `sigma = 1.5`.
Итог: общие рекомендации для начинающих работать с изображениями
----------------------------------------------------------------
1. Не используйте системные объекты Bitmap, HBITMAP и им подобные.
2. Прежде, чем использовать библиотеки для работы с изображениями, начните с написания велосипедов, а уже затем бросайтесь в бой.
3. Используйте тип float для хранения значений пикселей, если типа byte не хватает для хранения значений пикселей как по точности, так и по диапазону. А набравшись опыта, вы сможете использовать арифметику с фиксированной точкой и добиться максимальной эффективности.
4. При преобразовании из float в byte помните об ошибках округления и выход за границы типа.
5. Помните об отрицательных значениях.
6. Совершайте обход по пикселям изображения в правильном порядке.
7. Тщательно тестируйте код.
8. Не бойтесь плодить сущности. Код должен быть понятным.
9. Используйте математические операции с умом.
10. Учите язык.
11. Не пытайтесь показать мастерство.
12. Читайте учебники по обработке изображений — там много всего полезного пишут.
Для облегчения написания программ я создал проекты, в которых уже реализовано чтение и запись изображений, созданы классы для хранения изображений с минимально возможным функционалом и приведён пример операции над изображениями:
→ [Visual Studio 2015, C++](https://github.com/e673/improcbase-cpp)
→ [Visual Studio 2015, C#](https://github.com/e673/improcbase-cs)
Версий под Linux нет — студенты, использующие Linux, обычно не испытывают проблем с такими вещами.
Ну и на закуску — просто картинки.
Выделение контуров с помощью алгоритма Канни. Слева вверху — входное изображение, второе слева — правильный результат, остальное — ошибочные результаты.
| | | | | |
| --- | --- | --- | --- | --- |
| | | | | |
| | | | | |
Увеличение с помощью бикубической интерполяции.
| | | | | |
| --- | --- | --- | --- | --- |
| | | | | | | https://habr.com/ru/post/319606/ | null | ru | null |
# Dagaz: Эпизоды (часть 1)
***Мы расшатали ваши умственные фильтры, и в результате появился ответ. Метод сработал, он будет действенным всегда. Все, что необходимо сделать — это избавиться от лишнего груза предрассудков…
Раймонд Джоунс "[Уровень шума](http://lib.ru/INOFANT/DZHOUNS/noise.txt)"***
[Dagaz](https://glukkazan.github.io/) появился не на пустом месте. Я всегда увлекался настольными играми и головоломками, а программированием занимаюсь сколько себя помню, но мысль о некоем «универсальном» движке просто не могла бы прийти мне в голову. К самой этой идее я относился скептически. Пока не увидел [Zillions](http://www.zillions-of-games.com/). К сожалению, продукт, на тот момент, уже не развивался, исходный код был недоступен, да и вообще, программа работала только под Windows. Спустя некоторое время, я решил взяться за открытый проект.
Как я уже сказал, никаких исходных кодов у меня не было, но немного "[пощупав](http://zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?searchauthor=498)" Zillions, я уловил его главную идею — максимальное повторное использование прикладного кода, позволяющее использовать одни и те же конструкции в различных, казалось бы совершенно не похожих друг на друга случаях. Всё дело было в правильно подобранных usecase-ах. И я составил [план](https://github.com/GlukKazan/Dagaz/blob/master/doc/games.txt).
Шашки
-----
Это важное, но крайне недооценённое семейство игр заложило первый камень в фундамент проекта. Все «шашечные» игры похожи друг на друга и различаются лишь в деталях. С точки зрения игрового дизайна, все они объединяются тремя главными идеями:
* Шашечным взятием
* Приоритетом взятия
* Составным ходом
Первый пункт особых вопросов не вызывает, но если разработка ориентирована на шахматные игры, может оказаться неожиданностью. Далеко не во всех играх, взятие происходит на том же поле, где фигура завершает движение. С приоритетными ходами всё немного интереснее. В шашках, это правило позволяет строить сложную комбинационную игру, заманивая противника в ловушки, работающие по принципу «отдать меньше — забрать больше».
Разумеется, механизм приоритетных ходов был реализован в Zillions (и перекочевал оттуда в Dagaz). Без него практически все шашечные игры (безусловно входящие в «джентельменский набор» настольных игр обязательных к реализации) просто не могли бы работать правильно. Здесь всё дело в деталях. Посмотрим, как этот механизм был реализован:
**В Zillions**
```
(move-priorities jump-type normal-type)
...
(define checker-shift (
$1 (verify empty?) ; Двигаемся вперёд и проверяем что поле пусто
add ; Завершаем ход
))
(define checker-jump (
$1 (verify enemy?) ; Двигаемся вперёд и проверяем что там вражеская фигура
capture ; Берём её (вызов capture необходим - взятие не шахматное)
$1 (verify empty?) ; Двигаемся в том же направлении и проверяем что поле пусто
add ; Завершаем ход
))
...
(piece
(name Man)
(image White "images/stapeldammen/white.bmp"
Red "images/stapeldammen/red.bmp")
(moves
(move-type jump-type)
(checker-jump nw) (checker-jump ne) (checker-jump sw) (checker-jump se)
(move-type normal-type)
(checker-shift nw) (checker-shift ne)
)
)
```
Это практически полное описание простейшей шашечной игры. В [ZRF](https://ru.wikipedia.org/wiki/Zillions_of_Games) введено понятие режимов хода (**move-type**), а конструкция **move-priorities** позволяет сказать, что при наличии ходов более приоритетных (взятий), менее приоритетные (тихие ходы) рассматриваться не должны. Уровней приоритета может быть определено и больше двух, в этом плане, конструкция достаточно универсальна, но работая над играми в Dagaz, я столкнулся с некоторыми ограничениями этого механизма.
[](https://glukkazan.github.io/checkers/cheskers.htm)
В этой [игре](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%88%D0%BC%D0%B0%D1%82%D1%8B), придуманной Соломоном Голомбом, помимо шашек, присутствуют и шахматные фигуры. Сложность заключается в том, что взятие, оставаясь приоритетным для шашечных фигур, не является таковым для фигур шахматных (в противном случае их было бы слишком легко заманить в ловушку и съесть). Наивное определение приоритетов при помощи ключевого слова **move-priorities**, в этой игре, работать не будет.
В самом деле, если не включать взятия шахматными фигурами в состав приоритетных ходов, при наличии возможности взятия как шашечной фигурой так и шахматной, мы не сможем сходить шахматной фигурой, поскольку шашечное взятие приоритетно. Если же считать шахматные взятия столь же приоритетными, мы будем обязаны брать шахматными фигурами всегда, когда предоставится такая возможность. И то и другое противоречит правилам игры.
В Zillions эта проблема практически не решается. И это было главной причиной, по которой я задумался о введении в Dagaz механизма JavaScript-расширений. Идея, сама по себе, довольно простая: поскольку некоторые игровые механики довольно сложно выразить в ZRF, почему бы не ввести фазу пост-обработки ходов? Модуль расширения, в этом случае, просматривает весь список сгенерированных ходов целиком и может принимать решения об отбраковке тех или иных ходов. Вот как это [выглядит](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/games/checkers/cheskers-invariant.js) для "[Шашмат](https://glukkazan.github.io/checkers/cheskers.htm)":
**Простой и компактный код**
```
var CheckInvariants = Dagaz.Model.CheckInvariants;
Dagaz.Model.CheckInvariants = function(board) {
var design = Dagaz.Model.design;
var types = [];
types.push(design.getPieceType("Bishop"));
types.push(design.getPieceType("Camel"));
var isPriority = false;
_.each(board.moves, function(move) {
if (isCapturing(board, move)) {
if (_.indexOf(types, getType(board, move)) < 0) isPriority = true;
}
});
if (isPriority) {
_.each(board.moves, function(move) {
if (!isCapturing(board, move)) {
move.failed = true;
}
});
}
CheckInvariants(board);
}
```
В дальнейшем, идея расширений развивалась и цвела пышным цветом. Я получил удобный и мощный механизм для кодирования многих игр, реализация которых на чистом ZRF была бы крайне проблематична, но означает ли это, что определение приоритетов в стиле ZRF устарело? Разумеется нет! Во первых, написать одну строку на ZRF проще чем полсотни на JavaScript, но, что более важно, «жёсткие» приоритеты в стиле ZRF работают таким образом, что низко-приоритетные ходы даже не генерируются! Это важно, с точки зрения производительности. Генерация ходов в Dagaz — очень дорогая операция.
**Еще одна игра со сложными приоритетами**
[](https://glukkazan.github.io/checkers-like/dablot-prejjesne.htm)
[Dablot](https://en.wikipedia.org/wiki/Dablot_Prejjesne) — игра чем-то похожая на "[Итальянские шашки](https://ru.wikipedia.org/wiki/%D0%98%D1%82%D0%B0%D0%BB%D1%8C%D1%8F%D0%BD%D1%81%D0%BA%D0%B8%D0%B5_%D1%88%D0%B0%D1%88%D0%BA%D0%B8)", но более древняя. Помимо обычных фигур, в ней есть «принцы» и «короли» и младшие фигуры не имеют права бить старших. Но сложность не в этом. Для королей (а в некоторых разновидностях игры и для принцев тоже) взятие не является обязательным! Здесь возникает та же проблема, что и с [Шашматами](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%88%D0%BC%D0%B0%D1%82%D1%8B). Если мы объявим взятия королём приоритетными, то грубо нарушим правила игры, в противном же случае, мы не сможем бить королём при возможности альтернативного боя простой фигурой. Только механизм расширений Dagaz решает эту проблему.
Кстати, с «Итальянскими шашками» всё не так просто. Во многих разновидностях шашек существует правило гласящее, что игрок обязан брать максимальное количество фигур. То есть, не просто не может прервать цепочку взятий, а обязан выбрать тот путь, фигур на котором он возьмёт больше! По причинам, о которых я расскажу ниже, это правило не могло быть реализовано в Zillions в универсальном виде и разработчики были вынуждены его захардкодить. В итальянских шашках «правило большинства» звучит ещё сложнее: «бить нужно максимально возможное количество шашек соперника, а при равных вариантах боя нужно бить максимальное количество дамок».
Составные ходы — вторая важная составляющая шашечных игр. Настолько важная, что [тест](https://github.com/GlukKazan/Dagaz/blob/master/tests/checkers-test.js) на правильность взятия в "[Турецких шашках](https://glukkazan.github.io/checkers/turkish-dama.htm)" я периодически запускаю до сих пор. Пару раз, когда я ломал модель очередными изменениями, это действительно помогало.
**Ходы - составные и частичные**
**Посмотрим, как в ZRF реализованы составные ходы**
```
(define checker-shift (
$1 (verify empty?)
(if (in-zone? promotion)
(add King)
else
add
)
))
(define checker-jump (
$1 (verify enemy?)
capture
$1 (verify empty?)
(if (in-zone? promotion)
(add King)
else
(add-partial jump-type)
)
))
(define king-shift (
$1 (verify empty?)
add
))
(define king-jump (
$1 (verify enemy?)
capture
$1 (verify empty?)
(add-partial jump-type)
))
```
Вот так вот всё просто. Команда **add-partial** говорит, что ход можно продолжить (той же фигурой, это важно) если есть ещё ходы с указанным режимом. Иными словами: «фигура должна продолжать взятие, пока есть такая возможность». Вроде бы, всё замечательно, но есть один нюанс. Zillions рассматривает каждое такое взятие как отдельный «частичный» ход. Посмотрим, к чему это может привести.
[](https://glukkazan.github.io/elimination/mana.htm)
В этой [игре](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=2462), количество «шажков», выполняемых фигурой, определяется значком, на котором она стоит. Сейчас ход белых и ходит Damyo (фигура обозначенная красной бусинкой). В Zillions, выполнив два частичных хода, она легко может зайти в левый верхний угол, из которого уже не сможет сделать последний оставшийся ход (назад возвращаться нельзя). Брать фигуру противника на втором частичном ходу также запрещено. В Zillions нет никакой возможности, для того чтобы запретить последовательность ходов, заводящую в тупик.
В Dagaz — всё по другому! Последовательность частичных ходов **всегда** собирается в полный составной ход. Ход, который не удаётся завершить, попросту не соберётся! Это более ресурсозатратный подход, в результате чего генерация списка ходов в Dagaz — очень дорогая операция. Но и плюсы у него весомые. Например бот получает весь составной ход целиком и не должен просматривать позицию вперёд, выполняя оставшиеся частичные ходы.
Ещё более важно, что такой подход предоставляет возможность рассматривать весь список условно-допустимых ходов, выполняя более сложные проверки и запрещать одни ходы в зависимости от наличия других. Например «правило большинства», о котором я упоминал выше, в Dagaz реализуется совершенно [элементарно](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/games/checkers/maximal-captures.js). Причём, и для «Итальянских шашек» тоже. Разработчики Zillions «решили» известную им проблему для шашечных игр, захардкодив опцию "**maximal captures**", но существует огромное количество игр с другими сложными проверками, о которых они, на тот момент, не имели ни малейшего представления!
В процессе работы над новыми играми, концепция составного хода также развивалась. [Fanorona](https://glukkazan.github.io/checkers-like/fanorona-normal.htm) и [Pasang](https://glukkazan.github.io/pasang/pasang-01.htm) подсказали интересную игровую механику, в рамках которой группа снимаемых с доски фигур должна выбираться игроком, выполняющим ход:
[](https://glukkazan.github.io/checkers-like/fanorona-normal.htm)
Также, [Fanorona](https://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%BD%D0%BE%D1%80%D0%BE%D0%BD%D0%B0) — одна из тех редких игр, в которых игрок имеет право прерывать цепочку взятий. Первое взятие в ней обязательно, последующие, в рамках того же хода — на усмотрение игрока. В Dagaz эта опция (**pass-partial**) реализована ходом фигуры «на месте». Здесь могут быть missclick-и это, по всей видимости, не очень удобно, но с введением в проект [session-manager](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/kernel/controller/utils/session-manager.js)-а, ошибочные ходы стало возможно откатывать.
Дальнейшим развитием темы стали «стреляющие» ходы. Впервые я сделал их в [Hanga Roa](https://glukkazan.github.io/races/hanga-roa-board.htm) и [Ko Shogi](https://glukkazan.github.io/shogi/ko-shogi-board.htm), но, как выяснилось позже, сделал неправильно! Ошибочная реализация не работала под управлением ботов (а поскольку никаких ботов для обеих этих игр у меня нет до сих пор, не удивительно, что я ничего не заметил). Много позже, когда я делал "[Амазонок](https://glukkazan.github.io/stalemate/amazons.htm)", мне удалось локализовать проблему и исправить её. Своего расцвета эта идея достигла в [игре](https://glukkazan.github.io/breakthrough/chessball.htm), придуманной одним из наших соотечественников в далёком 1957 году.
[](https://glukkazan.github.io/breakthrough/chessball.htm)
Есть ещё одна проблема, связанная с реализацией составных ходов в Dagaz. Дело в том, что список допустимых ходов, из конкретного игрового состояния, формируется сразу — весь целиком. В Zillions, с её частичными ходами, это не очень критично, но в Dagaz, если фигура получит возможность «кружить на месте», фаза генерации хода никогда не будет завершена (очевидно, что исправить эту проблему расширениями невозможно, потому что до них дело просто не доходит). Вот одна из игр, для которых это важно:
[](https://glukkazan.github.io/races/super-chinese-checkers.htm)
Здесь фигуры с доски не убираются и одну и ту же фигуру можно перепрыгивать много раз подряд. Очевидным решением является запрет на посещение одного и того же поля дважды за ход, но мне пришлось основательно влезть в ядро, чтобы реализовать такую проверку. Это немножко напоминало реализацию опции "[отложенного взятия](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/games/checkers/deferred-captures.js)", но поскольку "[Русские шашки](https://glukkazan.github.io/checkers/russian-checkers.htm)" я делал гораздо раньше, то и проблем с ней было намного меньше.
**К сожалению, есть игры, в которых даже такие проверки не спасают**
В правилах [Stapeldammen](https://glukkazan.github.io/checkers/stapeldammen.htm) (это такая разновидность "[Столбовых шашек](https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%BE%D0%BB%D0%B1%D0%BE%D0%B2%D1%8B%D0%B5_%D1%88%D0%B0%D1%88%D0%BA%D0%B8)" явно указывается, что одну и ту же фигуру можно бить по нескольку раз за ход. Фигура, выполняющая ход, возвращается на одни и те же позиции по нескольку раз и продолжает бой, пока во вражеских столбиках есть фигуры. Составные ходы Dagaz не могут справиться с этой проблемой. Логика боя «Столбовых шашек» слишком сложна для ядра, а до расширений дело не дойдёт, поскольку поскольку генерация хода зацикливается. Разумеется, выход есть:
[](https://glukkazan.github.io/checkers/stapeldammen.htm?setup=+42;0:2=22;;0:2=22;+16;0:2=22;;0:2=22;;0:2;+5;0:1;+2;0:1;+20;&turn=0)
В Dagaz нет частичных ходов, но мы можем их сэмулировать, пропуская очередной ход противником (тот же подход используется в [манкалах](https://glukkazan.github.io/mancala/hawalis.htm)). И как раз эта логика легко реализуется [расширением](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/games/checkers/stapeldammen-restrictions.js). Просто запрещаем все ходы, при определённых условиях, а опция **pass-turn=forced** автоматически генерирует пустой ход. Вот ещё одна [игра](http://www.iggamecenter.com/info/en/pilare.html) с подобной эмуляцией.
[](https://glukkazan.github.io/stalemate/pilare-board.htm)
Искусственное разделение составных ходов на частичные не очень хорошо для AI ботов, но иногда, просто не остаётся другого выхода.
В общем, концепция составных ходов живёт и развивается. Совсем недавно, мне пришлось сделать ещё одну новую опцию (**complete-partial**) для одной древнеегипетской [игры](https://glukkazan.github.io/races/shen.htm).
Помимо автоматического завершения перемещения фигур по стрелочкам, в ней есть и другие интересные технические решения. Но об этом как-нибудь в другой раз. | https://habr.com/ru/post/459456/ | null | ru | null |
# Автоматизация веб-сервера FreeBSD8 Apache2+Mysql5 Часть 1
Так уж сложилось, что я жутко ленивый. Два года назад когда я приобрел себе VDS и встретился с FreeBSD 7.1 первый раз, убил две недели на настройку всего, что мне нужно было. Сейчас у меня 2\*Pentium III 1GHz / RAM 1Гб / 2\*SCSI 17Гб, под мои задачи он вполне подходит.
1. Создание хостов
2. Ротация логов Apache2
3. Архивация логов Apache2 и удаление старых логов.
4. Создание базы данных и добавление нового пользователя с правами только к одной базе, с генерацией нового пароля.
Мой любимый редактор vi. Если кто не знает как с ним работать можно везде где я указал vi заменять на свой ee,mcedit и т.д
Скрипт создания хостов.
Структура на моем сервере следующая, у каждого пользователя в хомдир лежит папка www, выглядит это так.
/home/user/www.
Скрипт внутри папки www создает каталоги с именем хоста.
Пример mk\_host.sh domen.ru user
в каталоге /home/user/www будет создана папка domen.ru с директориями
* cgi-bin
* html
* logs
* shadow
Также будет создан хост в директории Apache2. По моей схеме, для каждого виртуального хоста создается отдельный конфиг.
Смотрим сам скрипт.
`открываем новый файл
vi /root/bin/mk_host.sh
И пишем следующее.
> if [ $# -eq 2 ] ; then #Здесь скрипт проверяет, введены ли параметры
>
>
>
>
>
> path=/usr/local/etc/apache2/Includes # Устанавливаем путь до директории где будет создан виртуальный хост.
>
>
> domen=$1 #Первый параметр домен
>
>
> user=$2 # Второй параметр пользователь
>
>
> pathhome=/home/$user/www # Путь до веб-директории пользователя
>
>
> mkdir -p $pathhome/$1/html
>
>
> mkdir -p $pathhome/$1/shadow
>
>
> mkdir -p $pathhome/$1/cgi-bin
>
>
> mkdir -p $pathhome/$1/logs
>
>
> chown -R $user:$user $pathhome/$1/ #Выставляем владельца каталогов.
>
>
> #Далее создаем виртуальный конфиг
>
>
> echo "
>
>
> #Config for $domen
>
>
>
>
>
> DocumentRoot $pathhome/$domen/html/
>
>
> ServerName $domen
>
>
> ServerAlias www.$domen
>
>
> ScriptAlias /cgi-bin/ $pathhome/$domen/cgi-bin/
>
>
> CustomLog $pathhome/$domen/logs/web.log common
>
>
> ErrorLog $pathhome/$domen/logs/error.log
>
>
>
>
>
> #end of $domen" >>$path/$domen.conf
>
>
> else
>
>
> #Если пользователь при запуске скрипта не указал параметров, ему сообщается ошибка.
>
>
> echo "ERROR"
>
>
> echo "$0 domen name\_user"
>
>
> exit 1
>
>
> fi`
И на последок:
1. Скрипт нужно выполнять с правами root или как минимум нужно иметь доступ в директории.
2. Скрипт удобнее положить в свою директорию, например у меня в директории /root/bin/mk\_host.sh и добавить директорию в .profile, тогда у вас будет возможность запускать скрипт с любого места не указывая прямого пути к скрипту.
3. В скрипте есть только проверки на ввод двух параметров, к сожалению больше ничего не проверяется, скрипт сделан для себя, в надежде на то, что скриптом будет пользоваться опытный человек.
На всякий случай скрипт [в оригинале .](http://karpenko.biz/bash/mk_host.html)
И еще я люблю когда все лежит на своем месте и разложено по полочкам, описание остальных скриптов будет в следующей статье. | https://habr.com/ru/post/96933/ | null | ru | null |
# R и Информационная безопасность. Как устранить противоречие интересов и запустить R на Linux в оффлайн-режиме
Является продолжением [предыдущих публикаций](https://habrahabr.ru/post/342254/).
Очень часто попытки применить инструменты DataScience в корпоративной среде встают в полное противоречие с требованиями Службы Информационной Безопасности (СИБ). В мире DataScience рекомендация «поставь с гитхаба» становится практически нерешаемой при полной изоляции аналитической машины от интернета. Тем не менее, задача запуска на linux инфраструктуры R в offline окружении вполне решаемая. Ниже приведу последовательность мантр, которые позволят это исполнить. Если какие-то шаги будут не совсем прозрачными, то скорректирую по мере появления комментариев. Эти же шаги можно использовать и для online инсталляции, пропуская шаги, относящиеся к хитрым трюкам или созданию локальных репозиториев. Собрано по крупицам на основании многократных инсталляций под разнообразные задачи. Практика показала, что тема весьма актуальна.
Исходные допущения и обозначения
================================
* `srchost` — отдельная машина с доступом в Интернет;
* `dsthost` — целевая машина для инсталляции R аналитики;
* на обе машины установить CentOS 7 последней версии;
* с обеих машин доступны репозитории yum (rhel/centos и epel).
Установка пакетов в ОС, необходимых для работы R App
====================================================
Шаги исполняются на `srchost` и `dsthost`. В качестве `srchost` может выступать и просто Windows машина аналитика, тогда шаги по развертыванию `srchost` можно опустить.
На `srchost` пакеты устанавливаются из интернета, на `dsthost` — из локального репозитория. Далее `srchost` будет использоваться для создания miniCRAN.
```
sudo yum update
sudo yum -y install chrony
sudo systemctl start chronyd
sudo systemctl enable chronyd
sudo systemctl status chronyd
sudo yum -y install epel-release
uname -a
sudo yum -y install wget tree
sudo yum -y install wget libcurl-devel openssl-devel cyrus-sasl-devel libxml2-devel libpng-devel libjpeg-devel python python-devel proj proj-devel mesa-libGL mesa-libGL-devel mesa-libGLU mesa-libGLU-devel gmp-devel mpfr-devel cairo-devel libXt-devel gtk2-devel v8-devel udunits2 udunits2-devel xorg-x11-server-Xvfb unixODBC* postgresql-devel mariadb-devel mysql-devel gcc-gfortran* texlive*, ufw, dejavu*, psmisc, rrdtool, wireshark, lrzsz
sudo yum -y install dejavu-fonts-common dejavu-sans-mono-fonts rrdtool psmisc lrzsz gdal* proj-devel proj-epsg proj-nad protobuf-devel geos-devel
```
Ставим все, что касается LaTeX
------------------------------
Необходимо для работы RMarkdown
```
sudo yum -y install texlive texlive-latex texlive-xetex texlive-collection-fontsrecommended texlive-collection-latex texlive-collection-latexrecommended texlive-xetex-def texlive-collection-xetex
```
Устанавливаем шрифты
--------------------
Добавляем поддержку кириллицы:
```
sudo yum -y install texlive-cyrillic texlive-collection-langcyrillic texlive-cyrillic-doc texlive-framed texlive-titling texlive-*font* linux-liber*
```
Установка Roboto Condensed:
```
wget http://li.nux.ro/download/nux/dextop/el7/x86_64//google-roboto-common-1.2-2.el7.nux.noarch.rpm
wget http://li.nux.ro/download/nux/dextop/el7/x86_64//google-roboto-condensed-fonts-1.2-2.el7.nux.noarch.rpm
sudo yum localinstall google-roboto-common-1.2-2.el7.nux.noarch.rpm
sudo yum localinstall google-roboto-condensed-fonts-1.2-2.el7.nux.noarch.rpm
sudo fc-cache
```
Установка R
===========
```
sudo yum -y install R
```
Создаем репозиторий miniCRAN на srchost
---------------------------------------
Используем пакет miniCRAN для инициализации репозитория на `srchost`. Предполагаем, что она работает под управлением CentOS и на ней стоит R. Считаем, что локальная директория `/opt/miniCRAN`, куда будут загружаться необходимые пакеты, уже создана.
Ставим miniCRAN
```
sudo -i R
install.packages("miniCRAN") # инсталляция miniCRAN
```
Выкачиваем нужные нам пакеты (дополнить чего не хватает для вашего проекта) вместе с зависимостями
```
sudo -i R
library("miniCRAN")
tags <- c("tidyverse", "lubridate", "glue", "scales", "forcats", "readxl", "magrittr", "stringi", "stringr",
"futile.logger", "jsonlite", "Cairo", "RColorBrewer", "extrafont", "hrbrthemes", "DBI", "RPostgreSQL",
"config", "shiny", "shinyjqui", "shinythemes", "shinyBS", "shinyjs", "shinyWidgets", "shinycssloaders",
"formattable", "anytime", "tictoc", "digest", "officer", "openxlsx", "assertr", "checkmate", "udunits2",
"devtools", "DT", "data.table")
pkgList <- pkgDep(tags, suggests=TRUE, enhances=FALSE)
makeRepo(pkgList, path="/opt/miniCRAN", repos="https://cloud.r-project.org/", type=c("source"))
```
на `dsthost` вручную скопировать содержимое `/opt/miniCRAN`
set miniCRAN dir as default CRAN URI
------------------------------------
На `dsthost` в файле `/usr/lib64/R/library/base/R/Rprofile` дописываем
```
local({
uri <- paste0("file://", normalizePath("/opt/miniCRAN", winslash="/"))
options(repos = c(CRAN = uri))
})
```
Руками добавляем библиотеку ICU версии > 52
-------------------------------------------
На srchost
* Скачиваем пакет [ICU](https://raw.githubusercontent.com/gagolews/stringi/master/src/icu55/data/icudt55l.zip), требуемый для сборки `stringi`.
* Переносим пакет на dsthost и регистрируем:
+ Размещаем его в `/opt/icu55/data`.
+ Добавляем/исправляем путь к библиотеке в `/usr/lib64/R/etc/Renviron`:
```
# manual ICUDT
ICUDT_DIR=/opt/icu55/data
# --------------------
```
Подключение к MS SQL из-под linux требует доп. шагов по установке драйверов
---------------------------------------------------------------------------
["Установка Microsoft ODBC Driver for SQL Server для Linux и macOS"](https://docs.microsoft.com/ru-ru/sql/connect/odbc/linux-mac/installing-the-microsoft-odbc-driver-for-sql-server):
```
sudo su
curl https://packages.microsoft.com/config/rhel/7/prod.repo > /etc/yum.repos.d/mssql-release.repo
exit
sudo yum remove unixODBC-utf16 unixODBC-utf16-devel #to avoid conflicts
sudo ACCEPT_EULA=Y yum install msodbcsql
```
обновляем пакеты в R
--------------------
на `dsthost`
```
sudo -i R
update.packages(ask=FALSE)
```
Вручную собираем пакет `udunits2`
---------------------------------
После установки библиотек ищем расположение h файлов следующей командой `find . -type f -name udunits2.h` и запускаем инсталляцию пакета из консоли R со следующими параметрами:
```
install.packages("udunits2", configure.args='--with-udunits2-include=/usr/include/udunits2/')
```
Ставим пакеты в R средствами штатного `install.packages()`
----------------------------------------------------------
```
sudo -i R
install.packages(c("tidyverse", "lubridate", "glue", "scales", "forcats", "readxl", "magrittr", "stringi", "stringr",
"futile.logger", "jsonlite", "Cairo", "RColorBrewer", "extrafont", "hrbrthemes", "DBI", "RPostgreSQL",
"config", "shiny", "shinyjqui", "shinythemes", "shinyBS", "shinyjs", "shinyWidgets", "shinycssloaders",
"formattable", "anytime", "tictoc", "digest", "officer", "openxlsx", "assertr", "checkmate", "udunits2", "devtools", "DT", "data.table"))
```
Изменение переменных окружения, используемых в скриптах
-------------------------------------------------------
* Изменение переменных окружения на сервере linux
```
vi /etc/environment
R_CONFIG_ACTIVE=production
source /etc/environment
echo $R_CONFIG_ACTIVE
sudo systemctl restart shiny-server
```
Установка продуктов RStudio
===========================
на dsthost
Завести отдельного пользователя с uid > 100! от лица которого будем заходить в RStudio Server:
```
sudo useradd ruser
sudo passwd XXX
sudo usermod -aG wheel ruser # to make user 'sudo-user'
```
Установка RStudio Server free
-----------------------------
на `srchost`
1. download RStidio Server from link below [Страница загрузки](https://www.rstudio.com/products/rstudio/download-server/)
2. Copy RPM to remote server dsthost
on `dsthost`
3. install it using `rpm -ihv ./rstudio-server ... .rpm`
Установка RStudio Shiny Server free
-----------------------------------
на `srchost`
1. download Shiny Server from link below [Страница загрузки](https://www.rstudio.com/products/shiny/download-server/)
2. Copy RPM to remote server dsthost
3. install it using `rpm -ihv ./shiny-server ... .rpm`
Проверяем web доступ
--------------------
Shiny Server
* `http://:3838/` — общая стартовая страница с приложениями
RStudio Server
* `http://:8787`
Установка приложения
====================
на `srchost`:
1. Установка собственных пакетов с Github
* `cd /tmp` && `git clone https://github.com/path1/pack.git` (from bash on local server)
* copy `pack` to `/tmp` folder in remote server `dsthost`
* on remote server do in R: `devtools::install_local(path="/tmp/pack")`
2. Распаковка скриптов приложения с предоставленного дистрибутива в домашнюю директорию `~/R/` пользователя ruser
3. Оставляем режим работы Shiny Server для одного аналитика (ruser), делаем мапирование его домашней директории R на `/srv/shiny-server` командой `ln -s` :
`sudo ln -s /home/ruser/R/ /srv/shiny-server/`
4. Даем права на запись (пишется лог приложения)
`chmod -R go+rwx /home/ruser`
Можно работать
==============
Предыдущая публикация — [«Использование R для «промышленной» разработки»](https://habrahabr.ru/post/342254/). | https://habr.com/ru/post/345000/ | null | ru | null |
# 50+ сочных запоминающихся современных концепций инфографики на каждый день
В ответ на недавний топик о [MindMap](http://habrahabr.ru/blogs/lifehack/61254/#habracut) предлагаю вашему вниманию современные концепции визуализации и представления данных. Подробно разбирать каждую инфографику считаю излишним. Смотрим, вдохновляемся, комментируем…````Выше 2,58 Мб......[](http://www.onlinedisk.ru/view/153964/385383990a408e1e082o.jpg)Выше 267 Кб.....``Выше 147 Кб.....``Выше 63 Кб.....``Выше 150 Кб.....``Выше 220 Кб.....``Выше 96 Кб.....``Выше 111 Кб.....``Выше 115 Кб.....``Выше 180 Кб.....``Выше 166 Кб``Выше 30 Кб.....``Выше 223 Кб``Выше 200 Кб``Выше 184 Кб``Выше 232 Кб``Выше 330 Кб``Выше 125 Кб``Выше 95 Кб``Выше 60 Кб``Выше 172 Кб``Выше 115 Кб``Выше 158 Кб``70 Кб``Выше 128 Кб``Выше 88 Кб``Выше 233 Кб``Выше 180 Кб``Выше 34 Кб``Выше 194 Кб``Выше 78 Кб``Выше 1,53 Мб``Выше 120 Кб``Выше 155 Кб``Выше 93 Кб``Выше 120 Кб``Выше 50 Кб``Выше 1.28 Мб``Выше 4,23 Мб``Выше 124 Кб``Выше 100 Кб``Выше 244 Кб``Выше 80 Кб``Выше 45 Кб``Выше 87 Кб``Выше 460 Кб``Выше 4,6 Мб``Выше 280 Кб``Выше 680 Кб``Выше 80 Кб``Выше 55 Кб``Выше 60 Кб``Выше 65 Кб``Выше 70 Кб | https://habr.com/ru/post/61503/ | null | ru | null |
# Phoenix Framework – Webpack вместо Brunch, деплой с помощью Distillery и немного systemd
Эта статья является попыткой автора свести воедино в виде небольшого руководства несколько тем, с которыми, так или иначе, сталкиваются практически все разработчики веб-приложений, а именно – работа со статическими файлами, конфигурациями и доставкой приложений на сервер. На момент написания этого текста, последней стабильной веткой Phoenix Framework была ветка 1.2.х.
Кому интересно, почему не Brunch и как совместить миграции с Distillery – прошу под кат.
Phoenix для работы с JS-кодом и ассетами по-умолчанию использует [Brunch](http://brunch.io/) – возможно, очень простой и быстрый бандлер, но уж точно не самый распространенный и не самый мощный по возможностям и размеру экосистемы (и ответам на StackOverflow, конечно же). Поэтому и произошла замена Brunch на [Webpack](https://webpack.js.org/), де-факто – бандлер номер один в текущем мире фронт-энда.
А вот для решения вопросов деплоя, фреймворк не предоставляет практически ничего, кроме возможности подложить разные конфигурации для разных окружений. Судя по ответам разных разработчиков на форумах и прочих площадках, многие из них разворачивают свои приложения путем установки инструментов разработки прямо на боевом сервере и компилируя и запуская приложение с помощью Mix. По ряду причин, считаю такой подход неприемлемым, потому, перепробовав несколько вариантов упаковки приложения в self-contained пакет, я остановился на Distillery.
Т.к. статья является туториалом, то в качестве примера будет разработано абсолютно ненужное приложение, отображающее некий список неких пользователей. Весь код доступен на [GitHub](https://github.com/h8/userlist), каждый шаг зафиксирован в виде отдельного коммита, потому рекомендую смотреть историю изменений. Также, я буду давать ссылки на коммиты на определенных шагах, чтобы, с одной стороны, хорошо было видно по diff'у, какие изменения были сделаны, а с другой – чтобы не загромождать текст листингами.
Подготовка
----------
Итак, создадим шаблон нашего проекта, с указанием того, что Brunch мы использовать не будем:
```
$ mix phoenix.new userlist --no-brunch
```
Тут ничего интересного не происходит. Надо зайти внутрь нового проекта, поправить настройки базы данных в файле *config/dev.exs*, запустить создание репозитория Ecto и миграций ([коммит](https://github.com/h8/userlist/commit/cbfa0c924cc5b09dd80f9f21841ea40bb36470a0)):
```
$ mix ecto.create && mix ecto.migrate
```
Для того, чтобы сделать пример хоть немного нагляднее, я добавил модель сущности User, содержащую два поля – имя и бинарный признак, активен ли пользователь или нет ([коммит](https://github.com/h8/userlist/commit/b75e7f4793e50d6fd8687731e11b3610e16333a1)):
```
$ mix phoenix.gen.model User users name active:boolean
```
Далее, чтобы наполнить БД хоть какими-то данными, я добавил три экземпляра "пользователей" в файл *priv/repo/seeds.exs*, который и служит для таких целей. После этого можно выполнить миграцию и вставить данные в БД:
```
$ mix ecto.migrate && mix run priv/repo/seeds.exs
```
Теперь у нас есть миграция в *priv/repo/migrations/* – она нам пригодится в дальнейшем, а пока, надо еще добавить http API, по которому приложение сможет забрать список пользователей в формате JSON-объекта ([коммит](https://github.com/h8/userlist/commit/3f319b8e218dee030dc582b14db0194995944831)). Не буду загромождать текст листингами, diff на ГитХабе будет более нагляден, скажу лишь, что был добавлен контроллер, вью и изменен роутинг так, что у нас появилась "http-ручка" по пути */api/users*, которая будет возвращать JSON с пользователями.
На этом все с приготовлениями, и на данном этапе приложение можно запустить командой
```
$ mix phoenix.server
```
и убедится, что все работает, как задумано.
Статические файлы и JS
----------------------
Теперь обратим внимание на структуру каталогов проекта, а именно, на два из них – *priv/static/* и *web/static/*. В первом из них уже лежат файлы, которые нужны для отображения фениксовской "Hello, World!" страницы, и именно этот каталог используется приложением, когда оно запущенно, для отдачи статических файлов. Второй каталог, *web/static/*, по-умолчанию задействован при разработке, и Brunch (в проектах с ним), грубо говоря, перекладывает файлы из него в *priv/static*, попутно обрабатывая их ([статья в официальной документации об этом](http://www.phoenixframework.org/docs/static-assets)).
Оба вышеозначенных каталога находятся под управлением системы контроля версий, в оба из них можно добавлять файлы, вот только если вы добавите файлы сразу в *priv/static/*, то Brunch'ем они обработаны не будут, а если в *web/static/*, то будут, но если вы положите файл в *web/static/assets/*, то снова не будут… Мне кажется, что тут что-то пошло не так, потому я предлагаю более строгий подход, а именно:
* содержимое каталога *priv/static/* никогда не оказывается там в результате неких ручных действий, только в результате работы какого-то пайплайна. Более того, этот каталог выносится из VCS и добавляется в *.gitignore*;
* каталог *web/static/* содержит статические файлы, которые без изменений будут скопированы в */priv/static* соответствующим пайплайном при компиляции, сборке релизного пакета и т.д.
* все остальное, что должно оказаться в *priv/static/* (js, например) лежит где-то в другом месте в дереве исходников и попадает в результирующий каталог только через соответствующий пайплайн бандлера.
Итак, следующим шагом я почистил *priv/static* от ненужных файлов, а *robots.txt* и *favicon.ico* перенес в *web/static/* – вернемся к ним позже. Также, почистил html разметку главной страницы и ее шаблона ([коммит](https://github.com/h8/userlist/commit/c7402fd39be122593e20e4d526676b76b87b89aa)).
Перед тем, как добавлять Webpack, надо инициализировать сам NPM:
```
$ npm init
```
Получившийся package.json я почистил, оставив в нем только самое главное ([коммит](https://github.com/h8/userlist/commit/9d7d1355c7160c5e44856de325e9e11ca3683b41)):
```
{
"name": "userlist",
"version": "1.0.0",
"description": "Phoenix example application",
"scripts": {
},
"license": "MIT"
}
```
И после этого добавляем сам Webpack ([коммит](https://github.com/h8/userlist/commit/05ced21de8029ef6e64ec2a53fe84e6af5e38863)):
```
$ npm install --save-dev webpack
```
Теперь давайте добавим какой-то минимально возможный JS код к проекту, например, такой:
```
console.log("App js loaded.");
```
Для JS-файлов я создал каталог *web/js/*, куда и положил файл *app.js* с кодом выше. Подключим его в шаблоне *web/templates/layout/app.html.eex*, вставив перед закрывающим тегом :
```
">
```
Очень важно использовать макрос static\_path, иначе вы потеряете возможность загружать ресурсы с digest-меткой, что приведет к проблемам с инвалидацией кешей у клиентов и вообще, так не по правилам.
Создаем конфигурацию Webpack'а – файл webpack.config.js в корне проекта:
```
module.exports = {
entry: __dirname + "/web/js/app.js",
output: {
path: __dirname + "/priv/static",
filename: "js/app.js"
}
};
```
Из кода видно, что результирующий файл *app.js* будет находится в каталоге *priv/static/js/* как и задумывалось. На данном этапе можно запустить Webpack вручную, но это не очень удобно, так что добавим автоматизации, благо фреймворк это позволяет. Первое, что надо сделать, это добавить шорткат watch в секцию scripts файла *package.json*:
```
"scripts": {
"watch": "webpack --watch-stdin --progress --color"
},
```
Теперь Webpack можно запускать командой
```
$ npm run watch
```
Но и этого делать не надо, пускай этим занимается Phoenix, тем более, что у эндпоинта вашего приложения есть опция watchers, как раз и предназначенная для запуска подобных внешних утилит. Изменим файл *config/dev.exs*, добавив вызов npm:
```
watchers: [npm: ["run", "watch"]]
```
После этого, Webpack в режиме слежения за изменениями в каталогах и файлах будет запускаться каждый раз вместе с основным приложением командой
```
$ mix phoenix.server
```
Коммит со всеми вышеозначенными изменениями [тут](https://github.com/h8/userlist/commit/03bc107109b950f5a65978062a49253ed01d3c86).
C JS кодом немного разобрались, но еще остаются файлы в *web/static/*. Задачу по их копированию я тоже возложил на Webpack, добавив в него расширение copy:
```
$ npm install --save-dev copy-webpack-plugin
```
Сконфигурируем плагин в в файле *webpack.config.js*([коммит](https://github.com/h8/userlist/commit/16bd8bb6f1da097ce4eb5508df30d05aab4527cc)):
```
var CopyWebpackPlugin = require("copy-webpack-plugin");
module.exports = {
entry: __dirname + "/web/js/app.js",
output: {
path: __dirname + "/priv/static",
filename: "js/app.js"
},
plugins: [
new CopyWebpackPlugin([{ from: __dirname + "/web/static" }])
]
};
```
После данных манипуляций, наш каталог *priv/static/* начнет наполнятся двумя пайплайнами – обработанным JS и статическими файлами, не требующих таковой. В довершение данного этапа, я добавил отображение списка пользователей с помощью JS ([коммит](https://github.com/h8/userlist/commit/ca4c31b0fa9ca72b8c7c4a1a051ff5e80a6f7a08)), визуальным стилем для неактивных пользователей ([коммит](https://github.com/h8/userlist/commit/9ff22eeeb152c43988473c0f305819fd5bbfee7c)) и картинкой-логотипом для пущей наглядности работы пайплайна ([коммит](https://github.com/h8/userlist/commit/fc5eb18a49b8e1f3a94cced6138690eb5b56a56b)).
Может возникнуть вопрос – что делать, если надо производить пред-обработку, например, CSS. Ответ банален – выносить CSS в отдельный каталог, добавлять в Webpack соответствующие плагины и настраивать пайплайн, аналогичный используемому для JS. Либо использовать css-loader'ы, но это отдельная история.
Сборка релизного пакета. Distillery.
------------------------------------
Distillery это второй заход автора Exrm в попытке сделать хороший инструмент для пакетирования и создания релизных пакетов для проектов на Elixir. Ошибки первого были учтены, многое исправлено, пользоваться Distillery удобно. Добавим его в проект, указав как зависимость в *mix.exs*:
```
{:distillery, "~> 1.4"}
```
Обновим зависимости и создадим шаблон релизной конфигурации ([коммит](https://github.com/h8/userlist/commit/f7d489336e77e9143aaaf21584134d622cbcb3f9)):
```
$ mix deps.get && mix release.init
```
Последняя команда создаст файл *rel/config.exs* примерно такого содержания:
**Много кода**
```
Path.join(["rel", "plugins", "*.exs"])
|> Path.wildcard()
|> Enum.map(&Code.eval_file(&1))
use Mix.Releases.Config,
# This sets the default release built by `mix release`
default_release: :default,
# This sets the default environment used by `mix release`
default_environment: Mix.env()
environment :dev do
set dev_mode: true
set include_erts: false
set cookie: :"Mp@oK==RSu$@QW.`F9(oYks&xDCzAWCpS*?jkSC?Zo{p5m9Qq!pKD8!;Cl~gTC?k"
end
environment :prod do
set include_erts: true
set include_src: false
set cookie: :"/s[5Vq9hW(*IA>grelN4p*NjBHTH~[gfl;vD;:kc}qAShL$MtAI1es!VzyYFcC%p"
end
release :userlist do
set version: current_version(:userlist)
set applications: [
:runtime_tools
]
end
```
Предлагаю оставить его пока таким, как он есть. Указанного в конфигурации вполне достаточно: один релиз :userlist, он же :default, т.к. первый и единственный в списке релизов, а так же два окружения :dev и :prod. Под релизом здесь понимается OTP Release – набор приложений, который войдет в результирующий пакет, версию ERTS. В данном случае, наш релиз соответствует приложению :userlist, чего нам достаточно. Но, мы можем иметь несколько релизов и несколько окружений и комбинировать их по необходимости.
Distillery расширяется с помощью плагинов, так что можно организовать любой дополнительный пайплайн при сборке. Больше о плагинах [тут](https://hexdocs.pm/distillery/plugins.html#content).
Подготовим приложение к релизу. В первую очередь, надо отредактировать файл *config/prod.secret.exs*, поправим в нем настройки БД. Этот файл не добавляется в VCS, потому, в случае его отсутствия, его надо создать самому с примерно следующий содержанием:
**prod.secret.exs**
```
use Mix.Config
config :userlist, Userlist.Endpoint,
secret_key_base: "uE1oi7t7E/mH1OWo/vpYf0JLqwnBa7bTztVPZvEarv9VTbPMALRnqXKykzaESfMo"
# Configure your database
config :userlist, Userlist.Repo,
adapter: Ecto.Adapters.Postgres,
username: "phoenix",
password: "",
database: "userlist_prod",
pool_size: 20
```
Следующим важным этапом будет поправить конфигурацию Userlist.Endpoint в файле *config/prod.exs*. Прежде всего, заменить хост на нужный, а порт с 80 на читаемый из окружения параметр PORT и добавить важнейшую опцию server, которая является признаком того, что именно этот эндпоинт запустит Cowboy:
```
url: [host: "localhost", port: {:system, "PORT"}],
...
server: true
```
Далее, я добавил Babel к пайплайну обработки JS кода, т.к. UglifyJS, используемый по-умолчанию в Webpack, не обучен обращению с ES6:
```
$ npm install --save-dev babel-loader babel-core babel-preset-es2015
```
И секция настройки Babel в *webpack.config.js* после plugins:
**webpack.config.js**
```
module: {
loaders: [
{
test: /\.js$/,
exclude: /node_modules/,
loader: "babel-loader",
query: {
presets: ["es2015"]
}
}
]
}
```
И последнее – добавляем шорткат deploy в конфигурацию NPM ([коммит](https://github.com/h8/userlist/commit/9a57577bebb1ae318af9f6f15decadd4d46337c7)):
```
"scripts": {
"watch": "webpack --watch-stdin --progress --color",
"deploy": "webpack -p"
},
```
На данном этапе можно попробовать собрать и запустить релиз:
```
$ npm run deploy
$ MIX_ENV=prod mix phoenix.digest
$ MIX_ENV=prod mix release
$ PORT=8080 _build/prod/rel/userlist/bin/userlist console
```
Первой командой мы подготавливаем JS (минификация и т.п.), копируем static-файлы; вторая генерирует для всех файлов дайджест; третья непосредственно собирает релиз для соответствующего окружения. Ну и в конце – запуск приложения в интерактивном режиме, с консолью.
После релиза в каталоге *\_build* будет находится распакованная (exploded) версия пакета, а архив будет лежать по пути *\_build/prod/rel/userlist/releases/0.0.1/userlist.tar.gz*.
Приложение запустится, но при попытке получить список пользователей будет вызвана ошибка, т.к. миграции для этой БД мы не применили. В документации к Distillery [этот момент описан](https://hexdocs.pm/distillery/running-migrations.html#migration-module), я же немного упростил его.
Миграции
--------
После сборки, исполняемый файл приложения предоставляет нам одну из опций, которая называется command:
```
command [] # execute the given MFA
```
Это очень похоже на rpc, с разницей в том, что command выполнится и на не запущенном приложении – что нам и надо. Создадим модуль с функцией миграции, помня о том, что приложение запущенно не будет. Я разместил этот файл по пути *lib/userlist/release\_tasks.ex* ([коммит](https://github.com/h8/userlist/commit/373aa0f1584918c33a33ba76746fe2590368f1bf)):
```
defmodule Release.Tasks do
alias Userlist.Repo
def migrate do
Application.load(:userlist)
{:ok, _} = Application.ensure_all_started(:ecto)
{:ok, _} = Repo.__adapter__.ensure_all_started(Repo, :temporary)
{:ok, _} = Repo.start_link(pool_size: 1)
path = Application.app_dir(:userlist, "priv/repo/migrations")
Ecto.Migrator.run(Repo, path, :up, all: true)
:init.stop()
end
end
```
Как видно из кода, мы загружаем, а потом запускаем не все приложения, а ровно необходимые – в данном случае, это только Ecto. Теперь все, что осталось, это пересобрать релиз (только Elixir, т.к. остальное не менялось):
```
$ MIX_ENV=prod mix release
```
запустить миграции:
```
$ _build/prod/rel/userlist/bin/userlist command 'Elixir.Release.Tasks' migrate
```
и запустить приложение:
```
$ PORT=8080 _build/prod/rel/userlist/bin/userlist console
```
Вот, собственно, и все, но осталась еще пара мелочей. Например, запускать миграции таким способом, указывая полное имя модуля, функцию, не очень удобно. Для этого Distillery предоставляет хуки и команды (теперь другие).
Хуки и команды Distillery
-------------------------
Концепция хуков и команд проста – это обычные shell-скрипты, которые вызываются на определенном этапе жизни приложения (хуки), либо вручную (команды) и которые являются расширением главного исполняемого boot-скрипта. Хуки могут быть четырех видов: pre/post\_start и pre/post\_stop.
Я добавил пример двух хуков в проект, [смотрите код](https://github.com/h8/userlist/commit/0a4c7c0ede2bed45969593e40c3ae41310ca9bc1), он лучше всего объяснит, как это сделать.
В свою очередь, команды помогут скрыть ненужные подробности, чтобы, например, миграции выглядели как:
```
$ _build/prod/rel/userlist/bin/userlist migrate
```
Если вам нужен manifest.json
----------------------------
При сборке релиза, после выполнения команды phoenix.digest, все статические файлы получают хеш-сумму в свое имя (плюс добавляются сжатые версии), и генерируется таблица соответствия между исходным именем файла и новым, которая находится в файле *priv/static/manifest.json*, если вы не меняли его положение в конфигурации. Если вдруг вам понадобится информация из него во время выполнения приложения, то у вас два варианта:
* добавить его в список файлов, которые отдаются из каталога со статикой в *lib/userlist/endpoint.ex*:
```
only: ~w(css fonts images js favicon.ico robots.txt manifest.json)
```
после чего, его можно будет забрать Ajax'ом, например;
* если он нужен на бекенде, или если вы хотите рендерить его в шаблоне (я не знаю, зачем, но вдруг надо), то можно расширить LayoutView до такого:
```
defmodule Userlist.LayoutView do
use Userlist.Web, :view
def digest do
manifest =
Application.get_env(:userlist, Userlist.Endpoint, %{})[:cache_static_manifest]
|| "priv/static/manifest.json"
manifest_file = Application.app_dir(:userlist, manifest)
if File.exists?(manifest_file) do
manifest_file
|> File.read!
else
%{}
end
end
end
```
чтобы потом, где-то в шаблоне, написать следующее:
```
var digest = <%= raw digest() %>
```
Коммит с эти безумием [тут](https://github.com/h8/userlist/commit/40b4bcf55584bc219aea0194620d3bfd11e95ee2).
systemd
-------
Последнее, о чем хотелось бы упомянуть, это запуск приложения на боевом сервере. С тех пор, как у нас появился systemd, написание init-скриптов не то, что улучшилось, а стало просто элементарным.
Допустим, что мы будем разворачивать архив с приложением в */opt/userlist/* и запускать от имени пользователя userlist. Создадим файл *userlist.service* следующего содержания ([коммит](https://github.com/h8/userlist/commit/8a0d07982cb1ce8dfeb809bef870410899285a66)):
```
# Userlis is a Phoenix, Webpack and Distillery demo application
[Unit]
Description=Userlist application
After=network.target
[Service]
Type=simple
User=userlist
RemainAfterExit=yes
Environment=PORT=8080
WorkingDirectory=/opt/userlist
ExecStart=/opt/userlist/bin/userlist start
ExecStop=/opt/userlist/bin/userlist stop
Restart=on-failure
TimeoutSec=300
[Install]
WantedBy=multi-user.target
```
После чего, все, что надо сделать, это скопировать его в */etc/systemd/system/*:
```
$ sudo cp userlist.service /etc/systemd/system
```
Включить в "автозагрузку":
```
$ sudo systemctl enable userlist.service
```
И запустить приложение:
```
$ sudo systemctl start userlist
```
Заключение
----------
Целью данной статьи была попытка собрать воедино разрозненную информацию по разным темам, касающуюся Phoenix'а и дать какое-то более-менее цельное представление о жизненном цикле приложений, написанных на этом замечательном фреймворке. Очень много осталось за кадром, есть куча тем, достойная отдельных статей, например, способы доставки релизных пакетов на сервер и т.п.
Я, как автор, прекрасно понимаю, что могу ошибаться, потому заранее извиняюсь за ошибки или неточности и прошу писать о таковых в комментариях. | https://habr.com/ru/post/331598/ | null | ru | null |
# QML: анимированная иконка-«бутерброд» в стиле Material Design за 20 минут
Привет, Хабр.
Многие разработчики, интересующиеся разработкой пользовательских интерфейсов (да и просто пользователи Android) уже успели ознакомиться с новой концепцией интерфейса Material Design, активно продвигаемой Google в рамках выпуска Android 5.0. Знакомясь с [руководством по оформлению приложений](http://www.google.com/design/spec/animation/delightful-details.html) и внимательно разглядев недавно обновившийся Google Play, я обратил внимание на один очень симпатичный компонент — иконку меню (в народе известную как hamburger icon), анимированно превращающуюся в иконку «назад», и решил реализовать такой компонент на Qt с использованием декларативного языка описания интерфейса QML.
В этой статье я расскажу, как реализовать такой компонент и с какими проблемами и сложностями можно столкнуться в процессе. Ссылка на полный исходный код в конце поста.
**Примечания**Сразу приношу извинения за использование gif-анимации на главной странице, но без неё, к сожалению, становится совсем непонятно, о чём идёт речь.
Все скриншоты в статье будут приведены в масштабе 3:1 для удобства рассмотрения. Для понимания написанного требуются базовые представления о синтаксисе языка QML и поддерживаемых им возможностях.
Скачать дистрибутив библиотеки Qt и среды разработки Qt Creator для вашей ОС можно на [официальном сайте Qt](http://www.qt.io/download-open-source/).
Кстати, поддерживаемый Хабром тег source не поддерживает подсветку для исходников на QML, что может слегка затруднять чтение кода. Спасает только то, что количество кода мы постараемся минимизировать, насколько это возможно.
▌Подготовка
-----------
Для начала запустим Qt Creator и создадим проект типа «Интерфейс Qt Quick» — в данном примере мы будем использовать чистый QML и не напишем ни строчки кода на C++.
Сразу же создадим отдельный QML-файл для нашего компонента, так как мы предполагаем его использовать в дальнейшем и в других проектах, и установим стандартные размеры иконки для AppBar из Material Design: 24×24.
*MenuBackButton.qml*
```
import QtQuick 2.2
Item {
id: root
width: 24
height: 24
}
```
Подготовим корневой элемент проекта к отображению нашей иконки и зададим ему яркий фон в стиле Material Design:
*main.qml*
```
import QtQuick 2.2
Rectangle {
width: 48
height: 48
color: "#9c27b0"
MenuBackIcon {
id: menuBackIcon
anchors.centerIn: parent
}
}
```
▌Структура компонента
---------------------
Давайте внимательно посмотрим на наш компонент вблизи, чтобы разобраться, из чего он состоит и как всё это превратить в код.
Для начала мы можем сразу заметить, что у нашей иконки есть два основных [состояния](http://qt-project.org/doc/qt-5/qtquick-statesanimations-states.html): «меню» и «назад». Все остальные состояния являются промежуточными частями анимации при переходе между этими двумя. Сразу описываем это в QML:
*MenuBackButton.qml*
```
...
state: "menu"
states: [
State {
name: "menu"
},
State {
name: "back"
}
]
...
```
Для удобства отладки добавим в корневой элемент main.qml небольшой фрагмент, позволяющий нам переключать состояния иконки щелчком мыши:
*main.qml*
```
...
MouseArea {
anchors.fill: parent
onClicked: menuBackIcon.state = menuBackIcon.state === "menu" ? "back" : "menu"
}
...
```
▌Состояние «меню»
-----------------
Как несложно заметить, наша иконка состоит из трёх прямоугольников, которые в состоянии «меню» имеют одинаковый размер и располагаются друг над другом. Для получения элемента, пиксель-в-пиксель соответствующего оригинальному, я сделал несколько скриншотов приложения Google Play на своём смартфоне и подбирал координаты и размеры элементов, сравнивая получающийся результат со скриншотами.
Давайте добавим эти элементы в код:
*MenuBackButton.qml*
```
...
Rectangle {
id: bar1
x: 2
y: 5
width: 20
height: 2
}
Rectangle {
id: bar2
x: 2
y: 10
width:
height:
}
Rectangle {
id: bar3
x: 2
y: 15
width: 20
height: 2
}
...
```
Теперь можно запустить получившееся приложение и убедиться, что иконка в этом состоянии выглядит ровно так, как нам нужно.
▌Из чего состоит анимация
-------------------------
Для того, чтобы перейти к описанию состояния «назад», попробуем ещё раз внимательно приглядеться к тому, как выглядит анимация. Если этого не сделать сейчас, нам с некоторой вероятностью придётся переделывать уже написанный код, чего, конечно же, делать не хотелось бы.
Переход между состояниями компонента состоит из двух параллельно выполняемых анимаций:
* верхний и нижний прямоугольники уменьшаются в ширине, поворачиваются на 45° и смещаются к краю среднего прямоугольника, образуя «стрелку»
* все эти элементы одновременно переворачиваются на 180°
Я, конечно же, сразу не рассмотрел и попытался сделать анимацию поворота каждого из элементов в отдельности. Кода не сохранил и воспроизводить его совершенно не хочется, потому что получилась страшная ерунда. Не повторяйте мою ошибку :)
На самом деле, при попиксельном рассмотрении выясняется, что средний прямоугольник также анимируется — у него немного уменьшается ширина.
▌Состояние «назад»
------------------
Теперь, когда мы знаем, на какие грабли нам наступать не стоит, давайте опишем состояние «назад». Как мы уже выяснили, оно будет состоять из иконки «вперёд», перевёрнутой на 180° вокруг своей оси.
Для того, чтобы реализовать это в коде, мы используем QML-элемент [PropertyChanges](http://qt-project.org/doc/qt-5/qml-qtquick-propertychanges.html), позволяющий указать, каким образом должны меняться свойства элемента при переходе к другому состоянию. Заменяем описание состояния «back» на следующий код:
*MenuBackButton.qml*
```
...
State {
name: "back"
PropertyChanges { target: root; rotation: 180 }
PropertyChanges { target: bar1; rotation: 45; width: 13; x: 9.5; y: 8 }
PropertyChanges { target: bar2; width: 17; x: 3; y: 12 }
PropertyChanges { target: bar3; rotation: -45; width: 13; x: 9.5; y: 16 }
}
...
```
Обратите внимание, что установленное для корневого элемента свойство rotation действует также на все его дочерние элементы. Запускаем, щёлкаем мышкой по элементу… Ура! :)
При использовании данных координат всё выглядит отлично, но если сместить какие-то из элементов на полпикселя или пиксель в сторону, повёрнутые на угол, отличный от кратного 90°, прямоугольники могут начать выглядеть, прямо скажем, странно. Дело в том, что [свойство antialiasing](http://qt-project.org/doc/qt-5/qml-qtquick-rectangle.html#antialiasing-prop) элемента Rectangle по умолчанию включено только у прямоугольников со скруглёнными углами. Поэтому для получения более гладко выглядящей анимации и избежания разного рода проблем с отрисовкой, стоит к каждому из объявленных нами прямоугольников добавить установку свойства:
```
antialiasing: true
```
▌Анимация перехода
------------------
Теперь, описав оба нужных нам состояния элемента, пришло время позаботиться об анимации перехода между ними. Для этого мы воспользуемся элементами QML [Transition](http://qt-project.org/doc/qt-5/qml-qtquick-transition.html) и [PropertyAnimation](http://qt-project.org/doc/qt-5/qml-qtquick-propertyanimation.html).
Также, для большей гибкости в использовании, сразу объявим свойство animationDuration, которое позволит в дальнейшем менять длительность перехода, не влезая в код нашего элемента:
*MenuBackButton.qml*
```
...
property int animationDuration: 350
...
transitions: [
Transition {
PropertyAnimation { target: root; duration: animationDuration; easing.type: Easing.InOutQuad }
PropertyAnimation { target: bar1; properties: "rotation, width, x, y";
duration: animationDuration; easing.type: Easing.InOutQuad }
PropertyAnimation { target: bar2; properties: "rotation, width, x, y";
duration: animationDuration; easing.type: Easing.InOutQuad }
PropertyAnimation { target: bar3; properties: "rotation, width, x, y";
duration: animationDuration; easing.type: Easing.InOutQuad }
}
]
...
```
В элементе Transition обычно указываются свойства «to» и «from», задающие, на какую именно смену состояний этот переход должен действовать. Но так как состояний в нашем случае всего два и анимация перехода в обе стороны практически одинаковая, эти свойства можно не устанавливать.
Обратите внимание на свойство [easing.type](http://qt-project.org/doc/qt-5/qml-qtquick-propertyanimation.html#easing.type-prop) — этим свойством мы задаём кривую скорости анимации элементов. Дело в том, что анимация, которая выполняется с постоянной скоростью, выглядит обычно не слишком эстетично. Любое движение в реальном мире должно иметь период увеличения скорости при начале движения и период уменьшения скорости при его окончании. Собственно, на это же ссылается Google в [документе по Material Design](http://www.google.com/design/spec/animation/authentic-motion.html#authentic-motion-mass-weight).
Проверяем:
▌Победа? Не совсем.
-------------------
Мы почти закончили, но анимация вращения при переходе обратно в состояние «menu» работает не совсем так, как бы нам хотелось. В принципе, всё логично: угол поворота меняется в обратную сторону с 180° до 0°. Но это очень просто изменить:
```
...
RotationAnimation { target: root; direction: RotationAnimation.Clockwise;
duration: animationDuration; easing.type: Easing.InOutQuad }
...
```
Элемент [RotationAnimation](http://qt-project.org/doc/qt-5/qml-qtquick-rotationanimation.html) предназначен специально для таких случаев и позволяет указывать, в каком именно направлении будет осуществляться поворот. При желании, мы можем добавить нашему элементу свойство, позволяющее задавать направление анимации из вызывающего кода.
▌Результат и ссылки
-------------------
Данное руководство можно считать завершённым. Мы получили готовый компонент, пригодный к повторному использованию с минимальными доработками. Могу разве что предложить добавить свойство «color» для задания цвета элемента в случае использования его на светлом фоне.
Большим достоинством QML с моей точки зрения является как раз то, что код визуальных компонентов на нём во многих случаях получается легко читаемым и весьма компактным. Весь элемент у меня лично занял всего 60 строк кода и для него даже как-то неудобно создавать отдельный репозиторий на github, так что даю [ссылку на gist](https://gist.github.com/cyberbobs/8d62ab257d332914a72c). | https://habr.com/ru/post/243355/ | null | ru | null |
# Новости из мира OpenStreetMap № 503 (03.03.2020-09.03.2020)
Картатон в университете Сент-Луиса в городе Багио на Филиппинах [1](#wn503_22091) | Photo GOwin
Картографирование
-----------------
* Пользователи Stereo и contrapunctus предложили [упрощенный](https://wiki.openstreetmap.org/wiki/Proposed_features/Simpler_public_transport_route_relations) метод картирования маршрутов общественного транспорта. Он основан на их большом опыте подобной работы в Люксембурге и Дели соответственно. В списке рассылки «Тегирование» они [сообщили](https://lists.openstreetmap.org/pipermail/tagging/2020-March/051442.html), что жду наших с вами комментариев.
* Пользователь [Baloo Uriza](https://www.openstreetmap.org/user/Baloo%20Uriza) провел серьезную работу по приведению в должный вид [автострады 405](https://www.openstreetmap.org/relation/10401129) в Южной Калифорнии, большая часть которой не обновлялась со времен импорта [TIGER imports](https://wiki.openstreetmap.org/wiki/TIGER#History). В американском списке рассылки Talk он [делится](https://lists.openstreetmap.org/pipermail/talk-us/2020-March/019957.html) своими впечатлениями, а также размышляет о сложностях, которые возникают в результате картирования очень больших дорог.
* Мартин ван Эксел [представил](https://map.bingo/2020/03/04/introducing-some-more-maproulette-quick-fix-challenges-lanes-drive-thrus/) новый тип заданий в сервисе MapRoulette — Quick Fix (быстрое исправление). В отличие от традиционных задач MapRoulette, для выполнения этой не требуется открывать какой-либо редактор OSM, например, JOSM или iD. Сервис задает пользователю вопрос, на который можно ответить лиь «да» или «нет».
* Завершилось голосование за схему [тегирования](https://wiki.openstreetmap.org/wiki/Proposed_features/name:Zsye) `name:Zsye=*`, которая бы позволила картографам вносить в OSM названия, где используются эмодзи. Однако инициатива пользователя Ferdinand0101 не была поддержана сообществом.
Сообщество
----------
* Совет Фонда OSM отметил Международный женский день [публикацией](https://blog.openstreetmap.org/2020/03/08/openstreetmap-and-international-womens-day/), в которой размышлял на тему того, почему сложно определить, сколько женщин вносят свой вклад в OpenStreetMap, а также из-за чего одни люди делают больше или меньше, чем другие. Также отмечается, что причины, по которым люди (любого пола, происхождения или возраста) приходят в наш проект, по-видимому, у всех одни и те же: им нравится улучшать карту и радоваться, когда их труд оказался кому-то полезным.
* Мириам Гонсалес, одна из основательниц [Geochicas](https://wiki.openstreetmap.org/wiki/GeoChicas), упоминается в [статье](https://www.reuters.com/article/us-global-women-tech/visible-women-feminist-mappers-bridge-data-gap-in-urban-design-idUSKBN20V00H) Анастасии Молони о женщинах в картографии. В публикации говорится о том, что женщины-картографы, как правило, отмечают на карте то, что часто игнорируется мужчинами: больницы, службы по уходу за детьми, туалеты, приюты для жертв бытового насилия и женские поликлиники. Развернутые ответы Совета Фонда OSM по данной теме на вопросу Анастасии можно найти [здесь](https://wiki.osmfoundation.org/wiki/Officers_%26_Board/Press/2020-03-female_participation_in_OSM).
* В честь Международного женского дня гуманитарная команда OSM (HOT) [подвела](https://www.hotosm.org/updates/international-womens-day-2020-number-eachforequal/) свои итоги по гендерным достижениями за прошлый год и заявила о том, что ими будет предпринято для обеспечения гендерного равенства. В своем посте она также поделилась мыслями относительно того, что каждый из нас может сделать для того, чтобы в текущем году все больше женщин участвовало в составлении карт, чтобы появлялись карты для женщин и о женщинах.
* Mapillary и гуманитарная команда OSM запускают новую картографическую кампанию #map2020 для улучшения карт и навигации в странах с низким и средним уровнем дохода. Джессика Бергманн [приглашает](https://lists.openstreetmap.org/pipermail/hot/2020-March/015151.html) местные сообщества к участию в данной акции, а также отмечает, что лучший из лучших в качестве приза получит возможность абсолютно бесплатно побывать на конференции HOT Summit, которая пройдет в июне этого года в Кейптауне (ЮАР). В рамках акции [необходимо](https://blog.mapillary.com/update/2020/03/10/map2020-20.html) снимать панорамы улиц с помощью приложения Mapillary, что поспособствует улучшению навигации в их локациях. Заявки на участие должны быть поданы до 20 марта, а окончательные проекты — до 20 апреля.
* Марко Мингини [сообщил](https://lists.openstreetmap.org/pipermail/science/2020-March/000077.html), что прием заявок на участие и выступление на академической сессии конференции «State of the Map 2020» в Кейптауне (ЮАР) продлен до 26 марта.
* Натали Сидибе [опубликовала](https://www.openstreetmap.org/user/Nathalie%20SIDIBE/diary/392404) в своем дневнике пост, в котором она рассказала о своей биографии, причинах участия в OSM и поделилась достижениями.
* Энди Мэббетт [напомнил](https://lists.openstreetmap.org/pipermail/talk/2020-March/084260.html), что пять лет назад состоялись дебаты по поводу целесообразности добавления идентификаторов Викиданных в OSM. Энди приводит пример удачного проекта, который построен на использовании данного тега. Также он просит поделиться другими подобными проектами.
События
-------
* В настоящее время компания Jungle Bus проводит во франкоязычном сообществе OSM месячную картоакцию по добавлению и уточнению информации о зарядных станциях для электромобилей. Множество различных инструментов позволяет это делать, как «в полях», так и из дома. Больше информации о проекте можно найти в [WikiOSM](https://wiki.openstreetmap.org/wiki/FR:Project_of_the_month/bornes_vehicules_electriques). Хэштэг проекта — #balanceTaBorne
* Майкл Райхерт [объявил](https://lists.openstreetmap.org/pipermail/talk-de/2020-March/116672.html), что запланированная на 14 марта «Суббота OSM» на конференции FOSSGIS 2020 отменена из-за текущих событий.
* Из-за текущих событий, как [сообщает](https://lists.openstreetmap.org/pipermail/talk-de/2020-March/116673.html) Ларс Лингнер, также было отменено мероприятие «Berliner OSM Hackweekend», которое было запланировано на 28 и 29 марта.
Гуманитарный OSM
----------------
* Шон Флеминг [рассказал](https://news.microsoft.com/on-the-issues/2020/02/13/ai-missing-maps-hot-bing/) о том, как программа Microsoft «Искусственный интеллект для гуманитарной деятельности» работает с HOT и Bing, чтобы объединить картографирование по спутниковым снимкам, машинное обучение и добровольцев для создания нового поколения подробных карт. Инструменты, основанные на ИИ, помогают сделать добровольца более продуктивным, например, подсказывают, что этот объект — здание, а значит, ускоряют первоначальную идентификацию.
* Гуманитарная команда OpenStreetMap [приглашает](https://www.hotosm.org/updates/hot-summit-2020-call-for-sessions/) всех выступить с докладом или принять участие в работе секции на 6-й конференции HOT Summit, которая в этом году пройдет 1 и 2 июля в Кейптауне (ЮАР).
* HOT [объявила](https://www.hotosm.org/updates/join-us-this-summer-for-gsoc-and-outreachy-internships/) о своей программе стажировок в рамках Google Summer of Code и Outreachy, во время которой будут организованы краткосрочные оплачиваемые стажировки для типично недопредставленных людей.
* Добрые жители Питтсбурга, штат Пенсильвания, так любят свои [пикники](https://en.wikipedia.org/wiki/Fish_fry#Lenten_fish_fries) во время великого поста, во время которых они жарят рыбу, что несколько умных душ создали специальную карту, чтобы помочь жителям еженедельно находить любимые ими пикники. Эмили Меркурио [описывает](https://www.linkedin.com/pulse/its-back-2020-pittsburgh-lenten-fish-fry-map-mappers-emily/), как Холлен Бармер и проект "[Code for Pittsburg](https://codeforpittsburgh.github.io/)" использовали программное обеспечение с открытым исходным кодом и открытые геопространственные данные, чтобы создать платформу для волонтеров, где можно собирать, обновлять и обмениваться информацией об указанных пикниках.
Карты
-----
* Российский сервис заказа такси [«Таксовичкоф»](http://taxovichkof.ru/) использует в качестве карты OSM. Отметим, что они должным образом указали атрибуцию.
* Команда российских картографов [сделала](https://vk.com/feed?w=wall1694304_41454) подробную карту Южного Урала. Как [рассказал](https://t.me/ruosm/418154) один из участников проекта Алексей Клянин, в основе нее данные из OSM. С превью карты можно ознакомиться [здесь](https://www.exje.ru/product/karta_visoki_ural).
* На карте [coronavirus.app](https://coronavirus.app/?mode=infected) отображается количество людей, зараженных новым вирусом, в той или иной стране. В качестве подложки используется OSM.
Переходим на OSM
----------------
* Российское общественное движение «Антиборщевик», которое ставит своей целью борьбу с вредным и ядовитым сорняком борщевик сосновского, не так давно [перешло](https://vk.com/wall-145924850_3908) на OSM. Теперь их [карта](http://umap.openstreetmap.fr/ru/map/map_424586#9/55.7951/37.9138) выполнена на сервисе uMap, который использует OSM.
Открытые данные
---------------
* Недавно университет Сент-Луиса в городе Багио на Филиппинах провел свой первый картатон и был приятно удивлен количеством его участников. Пользователь GOwin по этому поводу [подготовил](https://www.openstreetmap.org/user/GOwin/diary/392407) красиво иллюстрированный пост, в котором он делится своими впечатлениями о мероприятии и его результатами.
* Не так давно сервис [OpenTrees.org](http://opentrees.org/), на котором сейчас отмечено 12 миллионов муниципальных уличных и парковых деревьев из 179 различных источников, стал [глобальным](https://twitter.com/stevage1/status/1234668059098406914).
Лицензии
--------
* Кристиан Квест [сообщил](https://lists.openstreetmap.org/pipermail/talk/2020-March/084299.html) об успехах акции французского сообщества OSM «Атрибуция — это не опция!», о которой мы [писали](http://www.weeklyosm.eu/en/archives/12950/#wn502_22048) ранее. На сайтах, использующих тайлы с сервера tile.openstreetmap.fr, но не указывающих должным образом атрибуцию, показывались тайлы, на которых было размещено требование — укажите атрибуцию. Напомним, что это необходимо делать в соответствии с пунктом 4.3 лицензии ODbL. Во время обсуждения этой новости одни [поддержали](https://lists.openstreetmap.org/pipermail/talk/2020-March/084316.html) такую инициативу, а другие — [нет](https://lists.openstreetmap.org/pipermail/talk/2020-March/084307.html). Интересно услышать мнение тех, кто еще не высказался.
Программное обеспечение
-----------------------
* Команда JOSM [сообщила](https://www.openstreetmap.org/user/josmeditor/diary/392391), что планирует удалить JavaScript API из JOSM, так как из Java удаляют JavaScript-движок Nashorn. Помимо этого, они рассказали о его влиянии на ядро JOSM.
Программирование
----------------
* Ник Уайтлегг [сообщил](https://lists.openstreetmap.org/pipermail/talk/2020-March/084284.html), что он начал вести новый [блог](https://hikar.org/wordpress/), в котором будет подробно рассказывать о разработке своих проектов Hikar (дополненная реальность с использованием OSM) и OpenTrailView (панорамы тропинок и дорожек).
* Российский пользователь Vascom, который не так давно стал еженедельно делать [карты](https://hide.webhop.me/mapsme/) для приложения Maps.Me (все регионы России и страны СНГ), поделился [скриптами](https://github.com/Vascom/mapsme), с помощью которых он это делает.
* Как [сообщил](https://t.me/ruosm/417073) разработчик игры Generation Street Роман Шувалов, в новой версии игры появилась возможность экспорта сгенерированных 3D-моделей в форматы .ply и .obj.
Релизы
------
* Вышла [новая](https://dbeaver.io/download/) версия (7.0.0) DBeaver SQL Client для Windows, MAC OS X и Linux. Этот клиент БД позволяет пользователям получать доступ/редактировать/проверять основные БД SQL. Основные изменения этой версии:
+ Улучшен интерфейс просмотрщика и редактора данных
+ Улучшен редактор SQL.
* В новой версии (9.6.0) известного мобильного навигационного приложения [Maps.Me](https://maps.me/) ([iOS](https://apps.apple.com/app/id510623322), [Android](https://play.google.com/store/apps/details?id=com.mapswithme.maps.pro&referrer=mt_click_id%3Dmt-ylr8m0-1583604834-2997579039)), которое использует карты на основе данных OSM, появились изолинии. Теперь навигация по горам и холмам стала чуточку проще. Функция доступна и в офлайн-режиме.
Знаете ли вы …
--------------
* … что команда разработчиков JOSM в Твиттере [напомнила](https://twitter.com/josmeditor/status/1236758769666797568?s=19) редакторам из Словакии, Бразилии, Чехии, Франции, Германии, Португалии и России о необходимости [включения](https://josm.openstreetmap.de/wiki/Rules) правил их стран в валидатор JOSM.
* … что существует [инструмент](https://www.mdpi.com/2220-9964/8/3/131) для QGIS для автоматического распознавания асбестовых кровель?
* … что представительство KFC в России для [отображения](https://www.kfc.ru/restaurants) своих ресторанов использует OSM?
* … про российский сайт "[Карта ДТП](https://dtp-stat.ru/)"? Его разработчики берут данные с официального портала статистики ГИБДД и размещают их на карте. В качестве картоосновы используется OSM.
OSM в СМИ
---------
* На сайте FingerLakes1.com вышла [статья](https://fingerlakes1.com/2020/03/03/openstreetmap-find-your-way-in-the-foreign-city-like-a-local/) про OSM — «OpenStreetMap: Найди свой путь в иностранном городе, как в своем». FingerLakes1 — это информационный портал района Фигнер лейкс в штате Нью-Йорке, где публикуются местные новости, спорт и погода.
Другие «гео» события
--------------------
* В журнале GPS World [опубликована](https://www.gpsworld.com/ai-helps-create-street-maps-from-satellite-imagery/) история о «RoadTagger» — модели искусственного интеллекта, разработанной Массачусетским технологическим институтом и Катарским вычислительным научно-исследовательским институтом для определения свойств дорог (тип или количество полос) по аэрофотоснимкам. Тестирование модели на 20 городах США (данные брались из OSM) показало, что она распознает количество полос с точностью до 77%, а тип дорожного покрытия — до 93%.
* Упендра Оли [создал](https://www.youtube.com/watch?v=Y5HebhSdmWQ) учебное видео о том, как с помощью QGIS анимировать изменение данных OSM во времени.
* Бельгийское отделение [Open Knowledge](https://be.okfn.org/) и [Noms Peut-Être](https://nomspeutetre.wordpress.com/) создали [карту](https://equalstreetnames.brussels/), на которой названия улиц Брюсселя подсвечиваются разными цветами в зависимости от пола того, в честь кого они названа. Только 6% улиц, названных в честь людей в Брюсселе, названы в честь женщин, и только одна улица названа в честь транссексуала. Пользователь Dries написал [пост](http://be.okfn.org/2020/03/03/equalstreetnames-brussels-launch-of-open-data-visualisation/) о создании и запуске этого проекта.
* Велосипедист, который отслеживал свое местоположение с помощью приложения RunKeeper, был допрошен полицейскими, так как оказалось, что он проезжал неподалеку от места преступления. Эта стало возможным благодаря тому, что Google после соответствующего запроса правоохранительных органов, [поделился](https://www.nbcnews.com/news/us-news/google-tracked-his-bike-ride-past-burglarized-home-made-him-n1151761) данными о гражданах, которые использовали его службы геолокации в этом месте.
---
Общение российских участников OpenStreetMap идёт в [чатике](https://t.me/ruosm) Telegram и на [форуме](http://forum.openstreetmap.org/viewforum.php?id=21). Также есть группы в социальных сетях [ВКонтакте](https://vk.com/openstreetmap), [Facebook](https://www.facebook.com/openstreetmap.ru), но в них в основном публикуются новости.
[Присоединяйтесь к OSM!](https://www.openstreetmap.org/user/new)
---
Предыдущие выпуски: [502](https://habr.com/ru/post/492444/), [501](https://habr.com/ru/post/491518/), [500](https://habr.com/ru/post/490686/), [499](https://habr.com/ru/post/489948/), [498](https://habr.com/ru/post/488298/) | https://habr.com/ru/post/493584/ | null | ru | null |
# Собираем систему потоковой аналитики из логов приложений
Приветствую, коллеги.
В этой статье хочу поделиться с вами опытом построения **системы мониторинга бизнес показателей в режиме реального времени,** которая построена на основе сбора логов.
Перед тем, как погрузиться в технические детали, немного расскажу о причинах построения системы с такой архитектурой.
Итак, представим, что у нас имеется некоторое количество приложений, которые изначально “не обучены” отдавать аналитику в режиме реального времени. Задача заключается в том, чтобы построить систему мониторинга бизнес-показателей с минимальным вмешательством в эти системы.
Существует множество способов решить эту задачу, и как водится, все они обладают своими достоинствами и недостатками. Основное достоинство описываемого способа заключается в очень простой реализации на стороне приложения (с которого есть необходимость получать аналитику). Но если бы мы сейчас разрабатывали все те приложения, которые нужно “научить” делиться аналитикой, то мы бы, наверное, их подружили с брокером сообщений типа Kafka или Rabbit, а внедрять в уже существующие приложения работу с брокером сообщений (особенно, если брокеры очередей сообщений не развернуты в компании) значительно сложнее, чем просто научить приложения писать свои показатели в лог.
Итак, рассмотрим подробно, как устроена предлагаемая система:
В основе системы лежат события, которые генерируют приложения. События сохраняются в лог (stdout, файл,..). Обработчик (сборщик) логов (в режиме реального времени) распознает в логах события приложений и отправляет их в хранилище (БД).
Система аналитики, выполняя запросы к хранилищу, получает значения (состояние) показателей приложения.
Для того, чтобы было возможным из лога выделить события приложений, сохранять их нужно в специальном формате. Мы будем использовать следующий шаблон для сохранения событий:
```
{"payload":"some data"}
```
Т.е. наши события будут передаваться в лог в виде JSON обернутого в тег event.
Для наглядности приведем пример строки лога, содержащего событие (форматирование добавлено для читаемости):
```
2022-10-11T21:37:48.055Z [app] info:
{
"source":"WMS",
"event":"order\_assembly\_start",
"data":{"order\_id": 101,
"employee\_id": 10,
"sku\_count": 5,
"sku\_weight": 1450,
"sku\_volume": 500
}
}
```
Общая архитектура решения выглядит следующим образом:
Поскольку система предполагает обработку логов приложений для извлечения событий и отправки их в хранилище, то бонусом к системе аналитики мы также можем получить централизованное хранилище логов, которое можно рассматривать как некоторую альтернативу ELK.
### Техническая реализация
Далее мы реализуем тестовый стенд для демонстрации работы предлагаемой системы. Для того, чтобы стенд было проще воспроизвести, все его части мы будем разворачивать в Docker контейнерах.
Наша реализация будет построена на следующих Open Source продуктах:
[Vector](https://vector.dev) - сборщик логов с возможностями ETL
[ClickHouse](https://clickhouse.com/docs/ru/) - OLAP база данных от Яндекс
[Grafana](https://grafana.com/) - платформа для визуализации данных и алертинга
В качестве примера наш стенд будет обрабатывать события из абстрактной [WMS](https://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D1%83%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D1%81%D0%BA%D0%BB%D0%B0%D0%B4%D0%BE%D0%BC) системы, которая посылает события о начале и завершении сбора заказа. Задача разрабатываемой системы заключается в том, чтобы отображать количество заказов, которые находятся в обработке в текущий момент и в динамике.
Напишем скрипт на [NodeJS](https://nodejs.org/en/), который будет имитировать работу WMS системы.
Его задача с некоторой периодичностью писать в лог события начала и завершения сборки заказа. События записываемые в лог будут иметь следующий формат:
Для события начала сборки заказа:
```
{
"source":"WMS",
"event":"order\_assembly\_start",
"data":{
"order\_id": 101,
"employee\_id": 10,
"sku\_count": 5,
"sku\_weight": 1450,
"sku\_volume": 500
}
}
```
Для события завершения сборки заказа:
```
{
"source":"WMS",
"event":"order\_assembly\_end",
"data":{
"order\_id": 101
}
}
```
Как видно из примера события имеют одинаковую структуру и содержат следующие поля:
*source* - источник события (приложение)
*event* - тип события
*data* - объект с данными произошедшего события.
Теперь приведем код скрипта на JavaScript генерирующего события:
index.js
```
'use strict'
const fs = require('fs');
const log_file = fs.createWriteStream(__dirname + '/../logs/demo-app.log', {flags : 'w'});
const log_stdout = process.stdout;
const randomInteger = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min;
const sleep = (ms)=>new Promise(res => setTimeout(res, ms));
console.mon = function(d, service='app', level='info') { //
const mess = typeof(d)==="string" ? d : `${JSON.stringify(d)}`;
const out = `${new Date().toISOString()} [${service}] ${level}: ${mess}\n`;
log_file.write(out);
log_stdout.write(out);
};
async function emulateWork(){
const processOrder = function (orderId, employee_id, sku_count, sku_weight, sku_volume){
const orderObjAssembly = {
source: 'WMS',
event: 'order_assembly_start',
data: {
order_id: orderId,
employee_id,
sku_count,
sku_weight,
sku_volume
}
}
console.mon(orderObjAssembly);
orderObjAssembly.event = 'order_assembly_end';
orderObjAssembly.data = {order_id: orderId}
setTimeout(()=>console.mon(orderObjAssembly), randomInteger(1,10)*1000);
}
let iteration = 0;
while (true){
console.mon(`iteration ${++iteration}`);
//orderId, employee_id, sku_count, sku_weight, sku_volume
processOrder(iteration, randomInteger(1,10), randomInteger(1,50), randomInteger(100,1000), randomInteger(1000,10000));
await sleep(1000);
}
}
emulateWork();
```
Вкратце о том, что делает приведенный выше код:
Функция *console.mon* пишет данные в лог файл *./logs/demo-app.log*,
В случае, если в функцию передается объект, то он записывается в лог в виде JSON и оборачивается в тег event.
Функция *emulateWork* имитирует поступление заказов, она каждую секунду генерирует поступление нового заказ который обрабатывается от 1 до 10 секунд.
Для того, чтобы запустить этот скрипт в Docker, подготовим docker-compose.yml конфиг:
docker-compose.yml
```
version: '3.8'
services:
main:
container_name: business-system-simulation
image: node:lts-alpine
working_dir: /home/node/app
user: "node"
volumes:
- ./:/home/node/app
- ./logs/:/home/node/app/logs:rw
command: npm run start
restart: always
```
Запустим docker контейнер выполнив команду:
> docker compose up
Если все сделано правильно, то в консоле должны начать отображаться сообщения записываемые в лог:
С приложением генерирующего логи мы закончили, теперь давайте настроим сборщик логов.
В качестве сборщика логов мы будем использовать Vector, с подробной документацией его возможностей и настройке можно ознакомится на официальном [сайте](https://vector.dev/) приложения. Представляет он из себя [ETL](https://ru.wikipedia.org/wiki/ETL) конвейер, задача которого состоит в том, чтобы из некоторого источника получить данные (extract), если нужно как то их преобразовать (transform) и загрузить в некоторую систему назначения (load).
Каждая такая задача извлечения, преобразования, отправки описывается в конфигурационном файле сборщика и оформляется в виде секций. Название секций заключены в квадратные скобки и должны иметь следующие префиксы:
[**sources**.section\_name] - для описания [источника данных](https://vector.dev/docs/reference/configuration/sources/),
[**transforms**.section\_name] - для описания [трансформации данных](https://vector.dev/docs/reference/configuration/transforms/)
[**sinks**.section\_name] - для описания места [назначения (загрузки) данных](https://vector.dev/docs/reference/configuration/sinks/).
Рассмотрим пример конфигурации сборщика:
vector.toml
```
[sources.debug_logs] # откуда сборщику логов брать данные.
type = "demo_logs" # в качестве источника логов будут использоваться демо данные, подробнее: https://vector.dev/docs/reference/configuration/sources/demo_logs/
format = "shuffle"
count = 3
lines = [ # массив демо данных
'2022-10-11T21:37:48.055Z [app] info: {"source":"WMS","event":"order\_assembly\_start","data":{"order\_id":1,"target":1}}',
'2022-10-11T21:37:56.056Z [app] info: {"source":"WMS","event":"order\_assembly\_end","data":{"order\_id":1,"target":1}}'
]
[transforms.remap_debug_logs] # Секция настроек описывающая трансформацию данных
inputs = ["debug_logs"] # Входные данные, ссылается на выше описанную секцию
type = "remap" # задает тип трансформации, документация: https://vector.dev/docs/reference/configuration/transforms/
file="/etc/vector/transform.vrl" # ссылка на файл с алгоритмом преобразования данных
[sinks.emit_debug_logs] # секция настроек описывающая место назначения
inputs = ["remap_debug_logs"] # Входные данные, результат работы предыдущей секции
type = "console" # Тип назначения (в консоль), документация: https://vector.dev/docs/reference/configuration/sinks/
encoding.codec = "json" # формат вывода данных
```
В этом примере в качестве источника данных используется несколько тестовых строк, которые прописаны непосредственно в конфигурационном файле, а в качестве места назначения логов используется вывод в консоль. Данные в нее выводятся в формате JSON. Это пример не использует каких-то внешних источников данных и нужен для того, чтобы разобраться с тем, как выполняется настройка сборщика, а также этот пример может помочь при отладке сборщика.
Как видно из конфигурации сборщика секция, которая отвечает за трансформацию данных [transforms.remap\_debug\_logs], ссылается на файл transform.vrl. В этом файле описан алгоритм преобразования данных. Каждая строка лога обрабатываемая сборщиком будет проходить через алгоритм трансформации описанный в этот файле.
Алгоритмы трансформации в сборщике логов Vector пишутся на языке Vector Remap Language, ознакомится с ним можно на [странице](https://vector.dev/docs/reference/vrl/) документации.
Ниже приведен код скрипта трансформации:
transform.vrl
```
#transform.vrl
.source= ""
.event = ""
.data = ""
structured, err = parse_regex(.message, r'()(?P.\*?)()', numeric\_groups: false)
if err == null{
json, err\_json = parse\_json(structured.event)
if err\_json == null {
.source= json.source
.event = json.event
.data = encode\_json(json.data)
}
}
```
Входные данные поступают в скрипт через переменную “.”. Эта переменная представляет из себя именованный массив, поля которого содержат данные передаваемые из источника данных.
В зависимости от типа источника данных набор этих полей может отличаться.
Данные возвращаемые скриптом трансформации также должны быть помещены в поля переменной “.”.
В нашем примере во входных данных (переменная “.”) содержится три поля:
*“message”* - содержит обрабатываемую строку лога,
*“source\_type”* - тип источника входных данных, в нашем примере она содержит строку “demo\_logs”,
*“timestamp”* - метка времени сборщика логов, время когда сборщик логов считал данные.
Опишем алгоритм этого скрипта:
Первым делом к объекту потока данных (переменной “.”) добавляем поля source, event, data - эти поля мы будем заполнять данными для системы мониторинга (в том случае если они были обнаружены в строке лога).
С помощью регулярного выражения из строки лога выделяем подстроку, содержащуюся внутри тега event и помещаем ее в поле event именованного массива structured, т.е. structured.event у нас содержится JSON, переданный в лог через тег event.
Далее мы преобразуем полученную JSON строку в объект и извлекаем из него поля source, event и data и помещаем их в наш объект с данными переменную “.”. В результате работы скрипта на выходе процесса преобразования (переменной “.”) мы получаем дополнительные поля “source”, “event” и “data”, в которых содержаться данные для системы мониторинга, если таковые были записаны в лог.
Подготовим конфигурацию docker контейнера для запуска нашего сборщика:
docker-compose.yml
```
#docker-compose.yml
version: "3.9"
services:
vector_agent:
image: timberio/vector:0.23.X-alpine
container_name: vector_agent
volumes:
- ./vector.toml:/etc/vector/vector.toml:ro
- ./transform.vrl:/etc/vector/transform.vrl:ro
```
Запустим docker контейнер, выполнив команду:
> docker compose up
В результате мы в консоль должны получить примерно такие сообщения:
```
business-system-simulation | 2022-10-28T06:59:22.384Z [app] info: {"source":"WMS","event":"order\_assembly\_start","data":{"order\_id":45,"employee\_id":2,"sku\_count":22,"sku\_weight":491,"sku\_volume":1523}}
```
Теперь давайте “скормим” нашему сборщику логи, которые генерирует наше тестовое приложение, для этого изменим его конфигурацию. Нам требуется изменить секцию входных данных [sources.debug\_logs], настроив ее таким образом, чтобы на вход сборщику подавался файл с логом приложения:
vector.toml
```
[sources.debug_logs]
type = "file"
include = ["/logs/*.log"]
[transforms.remap_debug_logs]
inputs = ["debug_logs"]
type = "remap"
file="/etc/vector/transform.vrl"
[sinks.emit_debug_logs]
inputs = ["remap_debug_logs"]
type = "console"
encoding.codec = "json"
```
Подключим папку с логами нашего тестового приложения к docker контейнеру сборщика логов:
docker-compose.yml
```
#docker-compose.yml
version: "3.9"
services:
vector_agent:
image: timberio/vector:0.23.X-alpine
container_name: vector_agent
volumes:
- ./vector.toml:/etc/vector/vector.toml:ro
- ./transform.vrl:/etc/vector/transform.vrl:ro
- ./../business-system-simulation/logs/:/logs/
```
Теперь наш сборщик логов должен выводить в консоль данные, которые пишутся в лог приложения:
Сообщение в консоль
```
{
"data": "{\"order_id\":70,\"target\":1}",
"event": "order_assembly_end",
"file": "/logs/demo-app.log",
"host": "bba028090efe",
"message": "2022-10-12T04:36:31.762Z [app] info: {\"source\":\"WMS\",\"event\":\"order\_assembly\_end\",\"data\":{\"order\_id\":70,\"target\":1}}",
"source_type": "file",
"timestamp": "2022-10-12T04:36:31.967280549Z"
}
```
Как вы наверное могли заметить, после смены источника данных в получаемых данных (переменной “.”) добавилось два дополнительных поля “file” и “host”, в которых соответственно находится ссылка на файл, с которого считывается лог и имя ПК.
Отложим ненадолго наш сборщик логов и создадим docker конфиг для нашей системы хранения [ClickHouse](https://clickhouse.com/docs/ru/):
docker-compose.yml
```
version: '3.7'
services:
ClickHouse-Server:
image: yandex/clickhouse-server
container_name: ClickHouse
ports:
- "8123:8123"
- "9000:9000"
volumes:
- ./db:/var/lib/clickhouse
# - ./users.xml:/etc/clickhouse-server/users.xml:rw
```
Запустим контейнер:
> docker compose up
Для дальнейшей работы нам понадобится в ClickHouse создать трех пользователей:
*admin* - админская учетная запись для управленя (полные права)
*agent* - учетная запись для сборщиков логов (доступ на добавление новых записей)
*monitoring* - учетная запись для мониторинга, будет использоваться Grafana (доступ только чтение)
По умолчанию в ClickHouse присутствует только пользователь default с пустым паролем и у этого пользователя нет прав на управление пользователями и ролями через запросы SQL. Для того что чтобы добавить эти права согласно [документации](https://clickhouse.com/docs/ru/operations/access-rights/#enabling-access-control), необходимо включить соответствующую настройку у пользователя в файле users.xml. Данный файл размещен внутри контейнера ClickHouse /etc/clickhouse-server/users.xml. Для удобства работы с этим файлом мы перенесем его из контейнера к себе на хост и пропишем ссылку на него из хоста в контейнер. Для того, чтобы скопировать файл из контейнера на хост, выполним команду:
> docker cp ClickHouse:/etc/clickhouse-server/users.xml /docker\_folder\_patch/users.xml
Прокинем ссылку на файл users.yml из хоста в docker контейнер, прописав в docker-compose.yml в разделе volumes ссылку:
- ./users.xml:/etc/clickhouse-server/users.xml
Теперь раскомментируем в файле users.xml у пользователя default настройку access\_management, сохраним файл и перезапускаем ClickHouse выполнив команду:
> docker-compose restart
Перейдем к созданию пользователей, для подключения к базе данных можно воспользоваться менеджером баз данных [DBeaver](https://dbeaver.io/) или любым другим, в наборе которого присутствует драйвер подключения к ClickHouse.
Для подключения используем:
адрес сервера: localhost
порт: 8123
имя пользователя: default
Подключившись к серверу ClickHouse выполним запрос:
> SHOW USERS
если в ответ получили:
default
значит у нашего пользователя есть необходимые привилегии и можно приступать к созданию пользователей.
Создадим пользователя admin в нашем случае с паролем qwerty:
> CREATE USER admin IDENTIFIED WITH sha256\_password BY 'qwerty';
И назначим ему полные права:
> GRANT ALL ON \*.\* TO admin WITH GRANT OPTION
Теперь когда у нас есть админская учетная запись, “обезвредим” учетную запись default. Для этого отредактируем файл users.xml: Комментируем обратно у пользователя default опцию access\_management, а в опции password пропишем пароль.
Следующие запросы выполняем под пользователем admin, которого ранее создали.
Создадим базу данных log\_storage для хранения логов:
> CREATE DATABASE IF NOT EXISTS log\_storage
Добавим пользователя agent:
> CREATE USER agent IDENTIFIED WITH sha256\_password BY 'qwerty';
установим ему права на чтение и запись в базе log\_storage:
> GRANT INSERT ON log\_storage.\* TO agent
> GRANT SELECT ON log\_storage.\* TO agent
Добавим пользователя monitoring:
> CREATE USER monitoring IDENTIFIED WITH sha256\_password BY 'qwerty';
Установим ему права только на чтение из базы log\_storage:
>GRANT SELECT ON log\_storage.\* TO monitoring
Для того чтобы проверить, какие права каким пользователям назначены, выполним запрос:
> SHOW ACCESS
На этом базовая настройка ClickHouse завершена.
Для дальнейшей настройки сборщика логов нам нужно создать таблицы, в которых будут храниться данные, получаемые из логов. Создадим таблицу “logs\_event”, в ней будут храниться события приложений:
logs\_event
```
CREATE TABLE log_storage.logs_event(
`timestamp` DateTime,
`source_type` String,
`host` String,
`source` String,
`event` String,
`data` String)
ENGINE = MergeTree()
PARTITION BY toYYYYMM(timestamp)
ORDER BY (timestamp, source_type, host, source, event);
```
А также создадим таблицу “logs\_app”, в ней будут храниться обычные логи приложений:
logs\_app
```
CREATE TABLE log_storage.logs_app(
`timestamp` DateTime,
`source_type` String,
`host` String,
`message` String)
ENGINE = MergeTree()
PARTITION BY toYYYYMM(timestamp)
ORDER BY (timestamp, source_type, host);
```
Теперь поменяем конфигурацию нашего сборщика, чтобы он отправлял в clickhouse логи приложения в таблицу “logs\_app”, а события приложения в таблицу “logs\_event”:
vector.toml
```
[sources.app_logs] # эта секция описывает настройки того откуда сборщику логов брать данные.
type = "file"
include = ["/logs/*.log"]
[transforms.remap_app_logs] # Секция настроек описывающая трансформацию данных
inputs = ["app_logs"] # Входные данные, ссылается на выше описанную секцию
type = "remap" # задает тип трансформации, документация: https://vector.dev/docs/reference/configuration/transforms/
file="/etc/vector/transform.vrl" # ссылка на файл с алгоритмом преобразования данных
[transforms.filter_events] # Секция фильтрации событий
inputs = ["remap_app_logs"]
type = "filter"
condition = '.event != ""'
[transforms.filter_logs] # Секция фильтрации лога приложения
inputs = ["remap_app_logs"]
type = "filter"
condition = '.event == ""'
[sinks.emit_events] # секция описывающая место доставки событий приложения
type = "clickhouse"
inputs = ["filter_events"]
endpoint = "http://192.168.229.133:8123"
auth.strategy = "basic"
auth.user = "agent"
auth.password = "qwerty"
database = "log_storage"
table = "logs_event"
skip_unknown_fields = true
encoding.timestamp_format = "unix"
batch.max_events = 100
batch.timeout_secs = 5
[sinks.emit_logs] # секция описывающая место доставки логов приложения
type = "clickhouse"
inputs = ["filter_logs"]
endpoint = "http://192.168.229.133:8123"
auth.strategy = "basic"
auth.user = "agent"
auth.password = "qwerty"
database = "log_storage"
table = "logs_app"
skip_unknown_fields = true
encoding.timestamp_format = "unix"
batch.max_events = 100
batch.timeout_secs = 5
```
Для наглядности приведем схему ETL процесса, описанной в конфигурации:
Опишем конфигурацию сборщика: в секции [sources.app\_logs] содержится настройка, откуда забирать логи приложений. Данные логов, полученные из секции [sources.app\_logs] поступают для преобразования в секцию [transforms.remap\_app\_logs] и в случае, если строка лога содержит событие (данные обернутые в тег event), то данные этого события извлекаются из строки лога и выносятся в отдельные поля source, event, data. После процесса преобразования данные лога поступают на фильтры [transforms.filter\_events] и [transforms.filter\_logs], задача которых состоит в том, чтобы разделить поток данных на два. На выходе [transforms.filter\_events] будут содержаться только события приложений, а на выходе фильтра [transforms.filter\_logs] только обычные логи. Определение того, является ли обрабатываемые данные событием или строкой лога, происходит по данным поля “event” которое заполняется именем события на этапе трансформации данных в секции [transforms.remap\_app\_logs] в результате работы скрипта “transform.vrl”.
Далее данные, прошедшие через фильтр [transforms.filter\_events], направляются в хранилище описанное в секции [sinks.emit\_events], а данные прошедшие через фильтр [transforms.filter\_logs] направляются в хранилище описанное в секции [sinks.emit\_logs].
В секциях настройки хранилищ описываются настройки подключения к базе данных ClickHouse и то, в какие таблицы будут доставляться данные. Хочется обратить особое внимание на следующие настройки хранилищ:
batch.max\_events = 100
batch.timeout\_secs = 5
Эти настройки заставляют сборщик логов выступать в роли буфера данных. Т.е. как видно из названия настроек, данные в хранилище будут отправляться раз в пять секунд или раньше, если накопится 100 элементов для отправки. Делается это для оптимизации работы ClickHouse, поскольку он отлично справляется с вставкой данных “пачками”, но крайне не любит “построчную” вставку.
Для того чтобы проверить, что все работает, запустим все наши контейнеры,после чего
выполним SQL запрос (например воспользовавшись DBeaver) к хранилищу ClickHouse:
> SELECT \* FROM log\_storage.logs\_event LIMIT 10
Если все сделано правильно и события из приложения передаются в хранилище, то мы должны получить примерно такой результат:
Итак, мы настроили наш сборщик на передачу событий и логов приложения в ClickHouse, но данные событий хранятся сериализованные в JSON, что не очень пригодно. Для извлечения данных из JSON у ClickHouse есть специальный набор [функций](https://clickhouse.com/docs/ru/sql-reference/functions/json-functions/). Воспользуемся ими для того, чтобы извлечь данные, хранящиеся в событиях:
Пример SQL
```
SELECT
`timestamp`,
`source`,
`event`,
JSONExtract(data, 'order_id', 'Int') AS order_id,
JSONExtract(data, 'employee_id', 'Int') AS employee_id,
JSONExtract(data, 'sku_count', 'Int') AS sku_count,
JSONExtract(data, 'sku_volume', 'Int') AS sku_volume,
JSONExtract(data, 'sku_weight', 'Int') AS sku_weight
FROM log_storage.logs_event
WHERE event ='order_assembly_start'
LIMIT 10
```
В результате получим данные, извлеченные из JSON и помещенные в одноименные колонки:
Для того, чтобы не писать такие громоздкие запросы, можно создать представление (view):
Пример создания View
```
CREATE VIEW log_storage.event_order_assembly_start__view AS
SELECT
`timestamp`,
`source`,
`event`,
JSONExtract(data, 'order_id', 'Int') AS order_id,
JSONExtract(data, 'employee_id', 'Int') AS employee_id,
JSONExtract(data, 'sku_count', 'Int') AS sku_count,
JSONExtract(data, 'sku_volume', 'Int') AS sku_volume,
JSONExtract(data, 'sku_weight', 'Int') AS sku_weight
FROM log_storage.logs_event
WHERE event ='order_assembly_start'
```
И теперь, написав запрос к представлению, мы получим аналогичный результат:
Запрос к View
```
SELECT
`timestamp`,
`source`,
`event`,
order_id,
employee_id,
sku_count,
sku_volume,sku_weight
FROM event_order_assembly_start__view
LIMIT 10
```
Минус использования таких представлений заключается в том, что если мы будем использовать в запросах условия по полям, которые хранятся в JSON, то движку базы данных придется сканировать все записи, содержащиеся в таблице-первоисточнике для проверки на условия запроса, что мягко говоря не самым лучшим образом скажется на производительности. Поэтому хорошим решением будет использовать [материализованные представления](https://clickhouse.com/docs/ru/sql-reference/statements/create/view/#materialized), поскольку такой вид представления фактически создает полноценную таблицу с данными описанных в запросе создания представления.
Создадим материализованное представление для события “order\_assembly\_start” :
Создание материализованного представления для события order\_assembly\_start
```
CREATE MATERIALIZED VIEW log_storage.event__order_assembly_start
ENGINE = MergeTree()
PARTITION BY toYYYYMM(timestamp) ORDER BY (timestamp, order_id, employee_id)
POPULATE
AS
SELECT
`timestamp`,
`source`,
`event`,
JSONExtract(data, 'order_id', 'Int') AS order_id,
JSONExtract(data, 'employee_id', 'Int') AS employee_id,
JSONExtract(data, 'sku_count', 'Int') AS sku_count,
JSONExtract(data, 'sku_volume', 'Int') AS sku_volume,
JSONExtract(data, 'sku_weight', 'Int') AS sku_weight
FROM log_storage.logs_event
WHERE event ='order_assembly_start'
```
А также создадим материализованное представление для события “order\_assembly\_end”:
Создание материализованного представления для события order\_assembly\_end
```
CREATE MATERIALIZED VIEW log_storage.event__order_assembly_end
ENGINE = MergeTree()
PARTITION BY toYYYYMM(timestamp) ORDER BY (timestamp, order_id)
POPULATE
AS
SELECT
`timestamp`,
`source`,
`event`,
JSONExtract(data, 'order_id', 'Int') AS order_id
FROM log_storage.logs_event
WHERE event ='order_assembly_end'
```
В результате события о начале и завершении сборки заказов будут храниться в представлениях “event\_\_order\_assembly\_start” и “event\_\_order\_assembly\_end”.
Возможно, в каких-то случаях будет лучше делать маппинг данных событий в таблицу назначения с помощью сборщика логов. В нашем случае тогда извлечение данных из события происходило бы на уровне скрипта трансформации данных и имело бы следующий вид:
transform.vrl
```
.source=
.event = ""
structured, err = parse_regex(.message, r'()(?P.\*?)()', numeric\_groups: false)
if err == null{
json, err\_json = parse\_json(structured.event)
if err\_json == null {
.source = json.source
.event = json.event
.order\_id = json.data.order\_id
.employee\_id= json.data.employee\_id
.sku\_count = json.data.sku\_count
.sku\_volume = json.data.sku\_volume
.sku\_weight = json.data.sku\_weight
}
}
```
и таблица для доставки данных, соответственно, должна была бы иметь все необходимые колонки. Такой способ будет предпочтителен в том случае, если мы извлекаем только один вид события из одного приложения. Но в случае большого количества приложений и видов событий поддержка скриптов трансформации станет трудоемкой задачей. Поэтому мы “сливаем” в clickhouse данные в виде JSON и уже на стороне clickhouse централизованно делаем маппинг данных событий при помощи материализованных представлений.
**Создание дашборда в Grafana**
Прежде всего подготовим конфигурацию docker контейнера для запуска Grafana:
docker-compose.yml
```
version: '3.7'
services:
grafana:
container_name: grafana
image: grafana/grafana-enterprise:9.2.0-ubuntu
environment:
- GF_SECURITY_ADMIN_USER=admin
- GF_SECURITY_ADMIN_PASSWORD=admin
volumes:
- ./provisioning/dashboards:/etc/grafana/provisioning/dashboards
- ./provisioning/datasources:/etc/grafana/provisioning/datasources
ports:
- "3000:3000"
restart: unless-stopped
```
Запустим docker контейнер
> docker compose up
Откроем в браузере адрес <http://localhost:3000>
Авторизация в Grafana, введя логин и пароль admin
Создадим в Grafana источник данных Clickhouse, но поскольку Grafana “из коробки” не поддерживает ClickHouse, сначала нужно установить плагин, который добавит к Grafana возможность работать с ClickHouse. Итак, переходим в Configuration -> Plugins
И в строке поиска вводим Clickhouse, из результатов поиска выбираем плагин ClickHouse и нажимаем Install:
Теперь Grafana поддерживает работу с ClickHouse. Создадим источник данных для работы с нашим хранилищем, для этого перейдем в Configuration -> Data sources
и нажмем кнопку Add data source, после чего в строке поиска введем Clickhouse и из предложенного результата выберем ClickHouse:
В открывшемся диалоге настроим соединение с ClickHouse, для этого введем следующие настройки:
Server address: вводим ip своего хоста
Server port: 9000
Username: monitoring
Password: qwerty
Default database: log\_storage
Остальные настройки оставим с значениями по умолчанию.
Нажмем кнопку “Save & test”, и если все сделано правильно, то должно появиться сообщение “Data source is working”:
Проверим работу соединения с clickhouse, для этого перейдем в раздел Explore
и установим настройки, как показано на изображении:
И нажмем кнопку Run query. Если все сделано правильно, то в нижней части страницы отобразится таблица с данными из ClickHouse.
Теперь напишем запрос, который будет выводить динамику количества заказов, находящихся в отборке за указанный период времени:
Запрос получения количества заказов в динамике
```
WITH
toStartOfDay(toDate('2022-10-20')) AS startDate,
toStartOfDay(toDate('2022-10-21')) AS endDate,
60 AS time_interval,
(SELECT groupArray((timestamp, order_id)) FROM log_storage.event__order_assembly_start WHERE timestamp BETWEEN date_add(DAY, -1, startDate) AND endDate) AS oredrs_start,
(SELECT groupArray((timestamp, order_id)) FROM log_storage.event__order_assembly_end WHERE timestamp BETWEEN date_add(DAY, -1, startDate) AND endDate) AS oredrs_end
SELECT time, assemble
FROM (
SELECT
time_series.time as time,
arrayMap(x->x.2, arrayFilter(x -> x.1 <= time, oredrs_start)) as orders_id_start,
arrayMap(x->x.2, arrayFilter(x -> x.1 <= time, oredrs_end)) as orders_id_end,
arrayIntersect(orders_id_start, orders_id_end) as orders_intersect,
length(orders_id_start) as orders_id_start_lengtht,
length(orders_intersect) as orders_intersect_length,
orders_id_start_lengtht - orders_intersect_length as assemble
FROM (SELECT arrayJoin(arrayMap(x -> toDateTime(x), range(toUInt32(startDate), toUInt32(endDate), time_interval))) time) time_series
)
```
В секции WITH задаются параметры запроса:
startDate - содержит начало периода,
endDate - содержит конец периода,
time\_interval - периодичность в секундах через которые нужно делать срезы данных.
В результате выполнения запроса должны получить данные следующего вида:
Пример результата запроса
```
time |assemble|
-------------------+--------+
2022-10-21 01:16:00| 3|
2022-10-21 01:17:00| 6|
2022-10-21 01:18:00| 5|
```
Теперь давайте создадим дашбоард в Grafana для того, чтобы отобразить эти данные в виде графика.
Для этого в Grafana воспользуемся меню Dashboards -> New dashboard
В открывшемся диалоге выбираем “Add new panel”.
И приступим к настройке виджета. По умолчанию виджет имеет тип Time series, оставим его как есть. Выберем в качестве источника данных (Data source) ранее нами созданный источник данных ClickHouse.
Теперь нужно написать запрос ,результат которого мы хотим отображать на графике.
Для виджета Time series запрос должен возвращать в первой колонке дату и время (метку времени), а во второй и последующих колонках - значения временных меток.
Коннектор ClickHouse позволяет настраивать запрос в двух режимах “Query Builder” и “SQL Editor”. Переключимся в режим “SQL editor” и введем в поле запроса запрос, который ранее мы уже использовали для отображения динамики собираемых заказов.
Для того, чтобы данные запрашивались согласно выбранного в Grafana периоде в запросе, нужно использовать макроподстановки. Их задача передать в запрос параметры, которые выбраны в интерфейсе Grafana. Подробнее о возможных макро выражениях, которые доступны для коннектора clickhouse, можно ознакомиться в [документации](https://grafana.com/grafana/plugins/grafana-clickhouse-datasource/).
В нашем запросе в секции WITH определены параметры: startDate, endDate и time\_interval
`WITH
toStartOfDay(toDate('2022-10-20')) AS startDate,
toStartOfDay(toDate('2022-10-21')) AS endDate,
60 AS time_interval,`
Заменим их статические значения на макро-выражения:
`WITH
$__fromTime AS startDate,
$__toTime AS endDate,
$__interval_s AS time_interval,`
Нажмем кнопку Run query для того, чтобы выполнить запрос.
Если все сделано правильно, то на виджете отобразится график с динамикой собираемых заказов:
Нажмем кнопку Apply для того, чтобы завершить настройку виджета.
Добавим еще один виджет для отображения количества заказов, которые на текущий момент находятся в сборке. Тип виджета выберем “Gauge”, и в качестве запроса введем:
SQL запрос для виджета Guage
```
WITH
$__fromTime AS startDate,
$__toTime AS endDate,
(SELECT groupArray((timestamp, order_id)) FROM log_storage.event__order_assembly_start WHERE timestamp BETWEEN date_add(DAY, -1, startDate) AND endDate) AS oredrs_start,
(SELECT groupArray((timestamp, order_id)) FROM log_storage.event__order_assembly_end WHERE timestamp BETWEEN date_add(DAY, -1, startDate) AND endDate) AS oredrs_end
SELECT assemble
FROM (
SELECT
arrayMap(x->x.2, arrayFilter(x -> x.1 <= endDate, oredrs_start)) as orders_id_start,
arrayMap(x->x.2, arrayFilter(x -> x.1 <= endDate, oredrs_end)) as orders_id_end,
arrayIntersect(orders_id_start, orders_id_end) as orders_intersect,
length(orders_id_start) as orders_id_start_lengtht,
length(orders_intersect) as orders_intersect_length,
orders_id_start_lengtht - orders_intersect_length as assemble
)
```
Сохраним и на дашборде получим примерно следующий результат:
Пожалуй, на этом закончим работу с Grafana, данные из приложения мы получили и вывели на дашборд, а наводить красоту можно бесконечно долго, что выходит за рамки этой статьи.
На что хотелось бы еще обратить внимание - так это на то, что работоспособность наших сборщиков нужно контролировать, и для этого у Vector есть возможность [отправки своих метрик](https://vector.dev/docs/administration/monitoring/#metrics) в Prometheus.
Также хочется отметить, что поскольку наше тестовое приложение работает в docker контейнере, а логирумые данные в том числе передаются в stdout, то мы можем в качестве источника данных для сборщика логов использовать [docker logs](https://vector.dev/docs/reference/configuration/sources/docker_logs/), что сильно упрощает сборку логов и избавляет нас от необходимости писать логи в файл. При использовании этого источника данных во входной переменной потока данных “.” добавляются поля “container\_name” и “stream” и их, соответственно, нужно добавить в таблицу назначения данных лога.
Часто системы сбора логов строятся с использованием брокеров очередей. Обычно это Kafka, в нашем тестовом стенде мы не стали этого делать, чтобы не усложнять систему, но добавить в наш систему Kafka достаточно просто поскольку используемый в нашем стенде сборщик логов Vector имеет возможность [отправлять данные в Kafka](https://vector.dev/docs/reference/configuration/sinks/kafka/), а в Clickhouse есть [специальный движок таблиц](https://clickhouse.com/docs/ru/engines/table-engines/integrations/kafka/), предназначенный для загрузки данных из Kafka.
Тут наверное должно быть заключение. Напишу его наверное после того как ознакомлюсь с вашей конструктивной критикой :)
GitHub с [исходниками](https://github.com/axilab/monitoring-by-logs). | https://habr.com/ru/post/697970/ | null | ru | null |
# Создание библиотеки компонентов с использованием Storybook
### Введение
В наши дни разработка интерфейса является достаточно затратным процессом который требует усилий от множества людей, разработчиков, дизайнеров, тестировщиков продукт менеджеров и так далее.
Компании все чаще прибегают к написанию интерфейса состоящего из множества независимых компонентов, которые могут быть использованы повторно. Многие дизайнеры создают дизайн проект который описывает каждую деталь дизайна. Они используют ряд инструментов для документирования интерфейсов, первые которые приходят на ум это axshare.com и zeplin.com. Тот же фотошоп, в котором у них все разложено строго по папочкам. Это позволяет им с легкостью работать над дизайном проекта, обновлять и добавлять новые страницы, просто копируя уже имеющиеся наработки.
А что же касается разработчиков? Да у нас есть Angular, React, Vue, Ember, Polymer. Все эти инструменты в той или иной мере позволяют нам создавать компоненты с дальнейшим их повторным использованием. Но скажите мне каким образом, вы можете взглянуть на проект так же как это делает дизайнер? Где я могу увидеть все компоненты которые используются в проекте, узнать их свойства или же просто попробовать? Как я могу узнать реализован ли нужный мне компонент? Такие вопросы уже начинают возникать в проектах среднего масштаба. Разумеется я могу пойти и спросить коллегу, но это излишнии коммуникации, которые неэффективны ввиду множества причин. Коллега попросту может не вникнуть в суть вашей проблемы и указать вам на схожий компонент который вы будете еще долго доделывать.
Типичная ситуация когда вы находитесь на стадии оценки новой функциональности, пройдясь по документации новой страницы которую вам предстоит разработать, все компоненты выглядят знакомыми, все они уже где-то используются и вы оцениваете новую задачу делая ставку на то, что некоторые компоненты уже реализованы. Договорившись о сроках и начав новый спринт, немного покопавшись в коде, вы в ужасе осознаете, что переиспользовать компонент не получится, что он зависит сугубо от других компонентов и вообще это все концептуально неверно.
У вас есть только два выхода
* Копипаст и создания еще одного похожего компонента.
* Разработка нового компонента, многофункционального компонента.
Разумеется есть и 3тий вариант, улучшить/расширить старый компонент. Но как подсказывает мне опыт, это еще затратней чем написать новый. Трудозатраты на исправление ошибок растут с каждым новым этапом развития проекта. Чем фундаментальней недороботка тем дороже ее исправлять.
Добросовестным выбором будет разработка нового компонента. Но тут вам передается эстафета того недобросовестного разработчика. Учитывая, что сроки горят, вы может быть и успеете разработать новый компонент, но сделать его общим у вас уже не будет времени.
На вопрос почему так произошло можно ответить следующим образом:
* Разработчик который разрабатывал компонент эгоист и не думал о будущей судьбе компонента.
* Раньше не планировалось переиспользование этого компонента где либо еще.
* Вы не знали, что этот компонент переиспользовать нельзя.
* Вы не знали о существовании более подходящего компонента.
С растущей тенденцией на распределенную разработку и компоненты которые можно повторно использовать, появляется необходимость в дополнительном инструментарии. Существует огромное количество различных инструментов под различные задачи и нужны фронт-енд разработчиков.
В этой статье я хотел бы осветить React Storybook для компонентов написанных с использованием React.js и Vue.js или даже React Native. С его использованием в проекте, можно с легкостью избежать описанных выше ситуаций.
> Storybook это окружения для разработки UI компонентов. Storybook позволяет просматривать библиотеку компонентов, увидеть различные состояния компонентов и интерактивно разрабатывать и тестировать компоненты.
> Storybook запускается отдельно от вашего приложения. Это позволяет разрабатывать компоненты в изоляции, что улучшает возможность переиспользование компонентов, тестируемость и скорость их разработки. Вы можете создавать новый компоненты быстро и без каких либо зависимостей основного проекта.
>
> Тут вы можете посмотреть примеры использования Storybook <https://storybook.js.org/examples>/
>
> Storybook имеет множество расширений и богатый API для расширения его функциональных возможностей, а также поддержку React Native.
Давайте рассмотрим использование Storybook с позиции различных участников процесса создания и второстепенных процессов поддержки интерфейса приложения.
#### Как UI\UX дизайнер
У вас будет возможность попробовать в живую и проверить реализованный разработчиком компонент. Увидеть все возможные состояние компонента и предоставить полноценный фидбек.
#### Как разработчик
У вас будет библиотека компонентов, вы больше не будете биться в догадках, есть ли у вас такой-то компонент или нет, вы сможете попробовать, поиграться с компонентом и узнать возможности его использования в рамках вашей текущей задачи. Это очень важно как для разработчика, иметь возможность увидеть все компоненты которые используются в проекте и знать все их особенности. Вы конечно же можете потратить уйму времени на изучение исходного кода, но будет куда проще найти нужный компонент с нужными свойствами визуально, а потом уже вдаваться в подробности.
Вы сможете разрабатывать компоненты в изолированном окружении, которое не требует поднятие всего проекта локально. Изолированное окружение не явным образом стимулирует вас разрабатывать компоненты с более продуманным API и с мыслью о возможности его переиспользования в любой части проекта. Вы думаете о входящих параметрах, с точки зрения пользователя и понимаете какие параметры были бы удобны потенциальному пользователю. Также вы задумываетесь об изоляции стилей. Помимо всего прочего, вы получаете настоящий верстак для разработки компонентов. Вы можете настроить окружение Storybook как вам угодно и использование таких вещей как HMR вы получаете из коробки.
#### Как тестировщик
У вас будет возможность тестировать каждый компонент в отдельности и независимо от других. Нет необходимости в запуске целого проекта. Вы можете просто открыть Storybook с интересующим вас компонентов и проводить абсолютно любые E2E тесты.
#### Как продакт менеджер
Продакт менеджер зачастую работает совместно с дизайнером, ведь это именно он говорит, какой бы функционал он хотел бы видеть. Как продукт менеджеру, работая над новой страницей вам будет полезно знать уже существующие элементы и иметь возможность попробовать их интерактивно. И словно дизайнер набросать новый скетч из уже существующих кусочков.
### Установка
Та как Storybook находит в экосистеме node/npm, это делается очень просто. Установить основной cli инструмент можно с помощью одного из ваших любимы пакетных менеджеров Yarn или NPM.
```
yarn global add @storybook/cli
```
Теперь вы можете использовать этот инструмент для инициализации Stroybook’а в вашем проекте.
Для экспериментов нам понадобится проект. В качестве примера возьмем заготовку из create-react-app. Я опущу описание и особености create-react-app, это очень полезный и простой для понимания инструмент, детальней вы можете прочитать [тут](https://github.com/facebookincubator/create-react-app).
Установим и создадим новый проект с помощью create-react-app
```
yarn global add create-react-app
```
Создадим проект
```
create-react-app my-app
```
Перейдем в директорию проекта
```
cd my-app
```
И запустим его
```
yarn start
```
В браузере откроется свеженький проект созданный с использованием create-react-app.
Теперь у нас есть приложение для экспериментов со Storybook, что ж давайте приступим.
Для того, чтобы инициализировать Storybook выполните следующую команду находясь в корне проекта
```
getstorybook
```
Эта команда определяет тип проекта, делает необходимые проверки и устанавливает зависимости
После чего в проекте появится новосозданные папки **.storybook** и **stories**
Папка **.storybook** содержит всевозможные конфигурационные файлы. С ними мы разберемся позже. На данный момент нас интересует папка **stories**.
В ней хранится библиотека компонентов. После инициализации Storybook в проекте, по умолчанию создается файл с одним примером. Давайте запустим Storybook и посмотрим на него.
```
yarn storybook
```
Storybook будет доступен по адресу <http://localhost:6006/>
Страница имеет простой интерфейс. Слева мы видим панель с иерархическими папками компонентов с возможностью поиска. Справа достаточно большая рабочая область, в которой будут отображаться ваши компоненты и прочая информация.
И панель снизу которая используется как интерактивный инструмент, на которую вы можете выводить различную информацию и элементы управления компонентов. Расположение этих панелей конфигурируется.
И так, давайте возьмем какой нибудь компонент за основу, чтобы не тратить время и не писать свой.
Я выбрал react-select
```
yarn add react-select
```
Создайте папку Select с файлом index.js в src следующего содержания
```
import React, { Component } from 'react';
import Select from 'react-select';
import 'react-select/dist/react-select.css';
class SelectWrapper extends Component {
state = {
value: null
}
onChange = (value) => {
this.setState({
value,
})
this.props.onChange(value)
}
render() {
return (
)
}
}
SelectWrapper.defaultProps = {
onChange: () => {}
}
export default SelectWrapper;
```
Это просто небольшая обертка для хранения состояния.
Теперь давайте добавим наш компонент в Storybook.
Делается это очень просто:
```
import Select from '../Select'
```
```
storiesOf("React select", module)
.add('General', () => )
```
Код интуитивно понятен. **storiesOf** создает категорию, в которую вы можете добавлять различные компоненты.
Давайте добавим react-select в наш Storybook с возможностью мультивыбора
```
storiesOf("React select", module)
.add('General', () => )
.add('With multi prop', () => ) // Мультивыбор
```
### Сборка Storybook
Не маловажной особенностью является возможность собрать Storybook в статичные файлы, которые можно будет например опубликовать на каком либо сайте или использовать внутри компании в качестве документации.
Просто запустите
```
yarn build-storybook
```
По умолчанию файлы складываются в **storybook-static**. Вы можете открыть их в любом браузере.
### Webpack и прочая конфигурация
По умолчанию Storybook пытается разобраться в вашем окружении и использовать ряд настроек которые позволяют собрать и отобразить Storybook. Но бывают случаи когда без дополнительной конфигурации не обойтись.
Вы можете добавить webpack.config.js в директорию .storybook.
Зачастую такой конфиг будет очень простым
```
// you can use this file to add your custom webpack plugins, loaders and anything you like.
// This is just the basic way to add additional webpack configurations.
// For more information refer the docs: https://storybook.js.org/configurations/custom-webpack-config
// IMPORTANT
// When you add this file, we won't add the default configurations which is similar
// to "React Create App". This only has babel loader to load JavaScript.
const mainConfig = require('../webpack.config')
module.exports = {
plugins: [
// your custom plugins
],
module: mainConfig.module
};
```
Как вы видите, это просто импорт конфига из основного проекта. В наших экспериментах вам данный конфиг не понадобится.
### Использование дополнений
Storybook имеет ряд рекомендуемых дополнений
* [storyshots](https://github.com/storybooks/storybook/blob/master/addons/storyshots) — Снапшот тестинг
* [actions](https://github.com/storybooks/storybook/blob/master/addons/actions) — Логирование действий
* [links](https://github.com/storybooks/storybook/blob/master/addons/links) — Создание ссылок между страницами Storybook
* [comments](https://github.com/storybooks/storybook/blob/master/addons/comments) — Комментирование
* [info](https://github.com/storybooks/storybook/blob/master/addons/info) — Аннотация компонентов
* [knobs](https://github.com/storybooks/storybook/blob/master/addons/knobs) — Редактирование пропертей компонентов
* [options](https://github.com/storybooks/storybook/blob/master/addons/options) — Кастомизирование UI Storybook’а
Давайте вернемся и посмотрим на созданные по умолчанию примеры
```
storiesOf('Welcome', module).add('to Storybook', () => );
storiesOf('Button', module)
.add('with text', () => Hello Button)
.add('with some emoji', () => )
```
дополнение **action**, создает своего рода функцию, результат выполнения которой вы увидете в Action Logger. Это может быть удобно для логирования параметров по типу onApply или onClick.
Достаточно полезными являются так называемые **knobs**. Они позволяют редактировать передаваемые параметры в компонент.
```
yarn add @storybook/addon-knobs
```
Необходимо импортировать установленный модуль в **addons.js** в директории **.storybook**
```
import '@storybook/addon-knobs/register'
```
И в **stories/index.js** импортировать необходимые нам **knobs**
```
import { withKnobs, text, boolean, number } from '@storybook/addon-knobs';
```
Давайте добавим возможность интерактивного манипулирования кнопкой
```
storiesOf('Button', module)
.addDecorator(withKnobs)
.add('with text', () => Hello Button)
.add('with some emoji', () => )
.add('Interactive demo', () => {text('Button text', 'Default')})
```
Теперь мы можем изменять текст кнопки и с помощью **boolean** задавать состояние кнопки.
Еще одним очень полезным дополнением является Info, данное дополнение автоматически документирует внешний API компонента.
```
yarn add @storybook/addon-info
```
Импортируете модуль
```
import { withInfo } from '@storybook/addon-info';
```
И давайте немного изменим код нашей кнопки
```
.add('Interactive demo 2', withInfo('doc string about my button component')(() =>
{text('Button text', 'Default')}
)
```
Справа появится кнопка, с помощью которой вы можете открыть подробную информацию о компоненте
Также можно отобразить эту информацию без необходимости ее открытия, прямо на рабочей области вместе с компонентом.
```
.add('Interactive demo 3', withInfo({
text: 'doc string about my button component',
inline: true,
})(() =>
{text('Button text', 'Default')}
))
```
### Заключение
React Storybook как вы видите, очень прост в использовании, имеет множество всевозможных настроек, дополнений и позволяет вам решить проблемы с поддержкой библиотеки компонентов. Остальные члены команды могут увидеть и попробовать компонент еще до того как он будет прикручен к странице, что позволяет получить фидбек от дизайнеров намного раньше. Новички в команде больше не будут теряться в догадках, есть ли у вас тот или иной компонент и можно ли его использовать в рамках текущей задачи. | https://habr.com/ru/post/340384/ | null | ru | null |
# PostgreSQL Antipatterns: насколько глубока кроличья нора? пробежимся по иерархии
В сложных ERP-системах **многие сущности имеют иерархическую природу**, когда однородные объекты выстраиваются в **дерево отношений «предок — потомок»** — это и организационная структура предприятия (все эти филиалы, отделы и рабочие группы), и каталог товаров, и участки работ, и география точек продаж,…
[](https://sbis.ru/all_services)
Фактически, нет ни одной [сферы автоматизации бизнеса](https://sbis.ru/all_services), где хоть какой-нибудь иерархии да не оказалось бы в результате. Но даже если вы не работаете «на бизнес», все равно можете легко столкнуться с иерархичными связями. Банально, даже ваше генеалогическое древо или поэтажная схема помещений в торговом центре — такая же структура.
Существует много способов хранения такого дерева в СУБД, но мы сегодня остановимся только на одном варианте:
```
CREATE TABLE hier(
id
integer
PRIMARY KEY
, pid
integer
REFERENCES hier
, data
json
);
CREATE INDEX ON hier(pid); -- не забываем, что FK не подразумевает автосоздание индекса, в отличие от PK
```
И пока вы всматриваетесь в глубину иерархии, она терпеливо ждет, насколько же [не]эффективными окажутся ваши «наивные» способы работы с такой структурой.
Давайте разберем типовые возникающие задачи, их реализацию на SQL и попробуем улучшить их производительность.
#1. Насколько глубока кроличья нора?
------------------------------------
Давайте, для определенности, примем, что эта структура у нас будет отражать подчиненность отделов в структуре организации: департаменты, дивизионы, секторы, филиалы, рабочие группы,… — как их ни назови.
**Сначала нагенерируем наше 'дерево' из 10K элементов**
```
INSERT INTO hier
WITH RECURSIVE T AS (
SELECT
1::integer id
, '{1}'::integer[] pids
UNION ALL
SELECT
id + 1
, pids[1:(random() * array_length(pids, 1))::integer] || (id + 1)
FROM
T
WHERE
id < 10000
)
SELECT
pids[array_length(pids, 1)] id
, pids[array_length(pids, 1) - 1] pid
FROM
T;
```
Начнем с самой простой задачи — найти всех сотрудников, которые работают внутри конкретного сектора, или в терминах иерархии — **найти всех потомков узла**. А еще и «глубину» потомка неплохо бы получить… Все это может быть необходимо, например, для построения какой-то [сложной выборки по списку ID этих сотрудников](https://habr.com/ru/post/486072/).
Все бы ничего, если этих потомков там всего пара уровней и количественно в пределах десятка, но если уровней больше 5, а потомков уже десятки — могут быть проблемы. Давайте посмотрим, как пишутся (и работают) традиционные варианты поиска «вниз по дереву». Но сначала определим, какие из узлов будут наиболее интересными для наших исследований.
Самые **«глубокие»** поддеревья:
```
WITH RECURSIVE T AS (
SELECT
id
, pid
, ARRAY[id] path
FROM
hier
WHERE
pid IS NULL
UNION ALL
SELECT
hier.id
, hier.pid
, T.path || hier.id
FROM
T
JOIN
hier
ON hier.pid = T.id
)
TABLE T ORDER BY array_length(path, 1) DESC;
```
```
id | pid | path
---------------------------------------------
7624 | 7623 | {7615,7620,7621,7622,7623,7624}
4995 | 4994 | {4983,4985,4988,4993,4994,4995}
4991 | 4990 | {4983,4985,4988,4989,4990,4991}
...
```
Самые **«широкие»** поддеревья:
```
...
SELECT
path[1] id
, count(*)
FROM
T
GROUP BY
1
ORDER BY
2 DESC;
```
```
id | count
------------
5300 | 30
450 | 28
1239 | 27
1573 | 25
```
Для этих запросов мы воспользовались типичным **рекурсивным JOIN**:
Очевидно, при такой модели запроса **количество итераций будет совпадать с общим количеством потомков** (а их ведь несколько десятков), и занимать это может достаточно существенные ресурсы, и, как следствие, время.
Проверим на самом «широком» поддереве:
```
WITH RECURSIVE T AS (
SELECT
id
FROM
hier
WHERE
id = 5300
UNION ALL
SELECT
hier.id
FROM
T
JOIN
hier
ON hier.pid = T.id
)
TABLE T;
```
[[посмотреть на explain.tensor.ru]](https://explain.tensor.ru/archive/explain/ff07dd16c7996df012dd9c06c7b2a6a0:0:2020-05-13)
Как и предполагали, мы нашли все 30 записей. Но потратили на это 60% всего времени — потому что сделали при этом и 30 поисков по индексу. А меньше — можно?
#### Массовая вычитка по индексу
А для каждого ли узла нам необходимо делать отдельный запрос к индексу? Оказывается, нет — читать из индекса мы можем **сразу по нескольким ключам за одно обращение** с помощью `= ANY(array)`.
А в каждую такую группу идентификаторов мы можем взять все найденные на предыдущем шаге ID по «узлам». То есть на каждом следующем шаге мы будем **искать сразу вообще всех потомков определенного уровня**.
Только, вот незадача, **в рекурсивной выборке нельзя обратиться к самой себе во вложенном запросе**, а нам ведь надо как-то отобрать именно только найденное на предыдущем уровне… Оказывается, сделать вложенный запрос ко всей выборке — нельзя, а вот к ее конкретному полю — можно. А это поле может быть и массивом — что нам и нужно для использования `ANY`.
Звучит несколько дико, но на схеме — все просто.
```
WITH RECURSIVE T AS (
SELECT
ARRAY[id] id$
FROM
hier
WHERE
id = 5300
UNION ALL
SELECT
ARRAY(
SELECT
id
FROM
hier
WHERE
pid = ANY(T.id$)
) id$
FROM
T
WHERE
coalesce(id$, '{}') <> '{}' -- условие выхода из цикла - пустой массив
)
SELECT
unnest(id$) id
FROM
T;
```
[[посмотреть на explain.tensor.ru]](https://explain.tensor.ru/archive/explain/35ee1ddc6a7ce3f05f982ca099af33b5:0:2020-05-13)
И тут самым важным является даже не **выигрыш в 1.5 раза по времени**, а что мы вычитали меньше buffers, поскольку обращений к индексу у нас всего 5 вместо 30!
Дополнительным бонусом идет тот факт, что после финального unnest идентификаторы останутся упорядочеными по «уровням».
#### Признак узла
Следующее соображение, которое поможет улучшить производительность — **у «листьев» не может быть детей**, то есть для них искать «вниз» вообще ничего не надо. В постановке нашей задачи это означает, что если мы шли по цепочке отделов и дошли до сотрудника, то дальше по этой ветке искать уже незачем.
Давайте введем в нашу таблицу **дополнительное `boolean`-поле**, которое будет нам сразу говорить, является ли эта вот конкретная запись в нашем дереве «узлом» — то есть могут ли у него вообще существовать потомки.
```
ALTER TABLE hier
ADD COLUMN branch boolean;
UPDATE
hier T
SET
branch = TRUE
WHERE
EXISTS(
SELECT
NULL
FROM
hier
WHERE
pid = T.id
LIMIT 1
);
-- Запрос успешно выполнен: 3033 строк изменено за 42 мс.
```
Отлично! Оказывается у нас только чуть больше 30% всех элементов дерева имеют потомков.
Теперь применим несколько иную механику — соединения с рекурсивной частью через `LATERAL`, что позволит нам сразу обратиться к полям рекурсивной «таблицы», а агрегатную функцию с условием фильтрации по признаку узла используем для уменьшения набора ключей:
```
WITH RECURSIVE T AS (
SELECT
array_agg(id) id$
, array_agg(id) FILTER(WHERE branch) ns$
FROM
hier
WHERE
id = 5300
UNION ALL
SELECT
X.*
FROM
T
JOIN LATERAL (
SELECT
array_agg(id) id$
, array_agg(id) FILTER(WHERE branch) ns$
FROM
hier
WHERE
pid = ANY(T.ns$)
) X
ON coalesce(T.ns$, '{}') <> '{}'
)
SELECT
unnest(id$) id
FROM
T;
```
[[посмотреть на explain.tensor.ru]](https://explain.tensor.ru/archive/explain/cdc1794a5d4890f7366d23a2659aac89:0:2020-05-13)
Мы смогли сократить еще одно обращение к индексу и **выиграли более чем в 2 раза по объему** вычитываемого.
#2. Вернемся к корням
---------------------
Этот алгоритм будет полезен, если вам необходимо собрать записи для всех элементов «вверх по дереву», сохранив при этом информацию, каким исходным листом (и с какими показателями) вызвано его попадание в выборку — например, для формирования сводного отчета с агрегацией на узлы.
Дальнейшее стоит воспринимать исключительно как proof-of-concept, поскольку запрос получается очень уж громоздкий. Но если он доминирует в вашей базе — стоит задуматься над применением подобных методик.
Начнем с пары простых утверждений:
* Одну и ту же запись из базы **лучше читать всего один раз**.
* Записи из базы **эффективнее читать «пачкой»**, чем поодиночке.
Теперь попробуем сконструировать нужный нам запрос.
### Шаг 1
Очевидно, что на инициализации рекурсии (куда же без нее!) нам придется вычитать записи самих листьев по набору исходных идентификаторов:
```
WITH RECURSIVE tree AS (
SELECT
rec -- это цельная запись таблицы
, id::text chld -- это "набор" приведших сюда исходных листьев
FROM
hier rec
WHERE
id = ANY('{1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192}'::integer[])
UNION ALL
...
```
Если кому-то показалось странным, что «набор» хранится строкой, а не массивом, то этому есть простое объяснение. Для строк существует встроенная агрегирующая «склеивающая» функция `string_agg`, а для массивов — нет. Хотя ее и [несложно реализовать самостоятельно](https://stackoverflow.com/questions/6782268/array-agg-for-array-types).
### Шаг 2
Теперь нам бы получить набор ID разделов, которые надо будет вычитать дальше. Почти всегда они будут дублироваться у разных записей исходного набора — поэтому нам бы **их сгруппировать**, сохранив при этом информацию о листьях-источниках.
Но тут нас поджидают три неприятности:
1. «Подрекурсивная» часть запроса не может содержать агрегатных функций с `GROUP BY`.
2. Обращение к рекурсивной «таблице» не может находиться во вложенном подзапросе.
3. Запрос в рекурсивной части не может содержать CTE.
К счастью, все эти проблемы достаточно легко обходятся. Начнем с конца.
#### CTE в рекурсивной части
Вот так **не** работает:
```
WITH RECURSIVE tree AS (
...
UNION ALL
WITH T (...)
SELECT ...
)
```
А так — работает, скобочки решают!
```
WITH RECURSIVE tree AS (
...
UNION ALL
(
WITH T (...)
SELECT ...
)
)
```
#### Вложенный запрос к рекурсивной «таблице»
Хм… Обращение к рекурсивной CTE не может быть во вложенном запросе. Но оно может быть внутри CTE! А вложенный запрос может обращаться уже к этой CTE!
#### GROUP BY внутри рекурсии
Неприятно, но… У нас же есть простой способ, как можно сэмулировать GROUP BY с помощью `DISTINCT ON` и оконных функций!
```
SELECT
(rec).pid id
, string_agg(chld::text, ',') chld
FROM
tree
WHERE
(rec).pid IS NOT NULL
GROUP BY 1 -- не работает!
```
А вот так — работает!
```
SELECT DISTINCT ON((rec).pid)
(rec).pid id
, string_agg(chld::text, ',') OVER(PARTITION BY (rec).pid) chld
FROM
tree
WHERE
(rec).pid IS NOT NULL
```
Вот теперь мы видим, зачем числовой ID превращался в текст — чтобы их можно было склеивать через запятую!
#### Шаг 3
Для финала нам осталось всего ничего:
* вычитываем записи «разделов» по набору сгруппированных ID
* сопоставляем вычитанные разделы с «наборами» исходных листов
* «разворачиваем» строку-набор с помощью `unnest(string_to_array(chld, ',')::integer[])`
```
WITH RECURSIVE tree AS (
SELECT
rec
, id::text chld
FROM
hier rec
WHERE
id = ANY('{1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192}'::integer[])
UNION ALL
(
WITH prnt AS (
SELECT DISTINCT ON((rec).pid)
(rec).pid id
, string_agg(chld::text, ',') OVER(PARTITION BY (rec).pid) chld
FROM
tree
WHERE
(rec).pid IS NOT NULL
)
, nodes AS (
SELECT
rec
FROM
hier rec
WHERE
id = ANY(ARRAY(
SELECT
id
FROM
prnt
))
)
SELECT
nodes.rec
, prnt.chld
FROM
prnt
JOIN
nodes
ON (nodes.rec).id = prnt.id
)
)
SELECT
unnest(string_to_array(chld, ',')::integer[]) leaf
, (rec).*
FROM
tree;
```
[[посмотреть на explain.tensor.ru]](https://explain.tensor.ru/archive/explain/4a6a45f4c5076fe269676af554348524:0:2020-05-13) | https://habr.com/ru/post/501614/ | null | ru | null |
# QEMU-KVM под LXC
**Как обычно — обстоятельства диктуют правила.** На этот раз мы ставим Proxmox и Libvirt на один тот же сервер.
Столкнулись с очередной задачей — заказчик поставил условие развернуть стенд на уже имеющейся, конфликтующей инфраструктуре. У него кластер Proxmox, у нас Libvirt
Решение в лоб — не помогло, попытка установить libvirtd потребовала удаления proxmox. Не долго думая решили скреативить. Смотрите под катом элегантное решение как и на ёлку залезть и ничего не ободрать.
Коротко о нас — команда разработчиков WriteX Team. Работаем с Linux с 2000го года под девизом — нет ничего невозможного для Linux. Сказано — сделано. пошли думать. Варианты развития: скомпилировать libvirt либо уйти в контейнер. Гугл как обычно помог, нашел очень полезную статью: [stgraber.org/2014/01/01/lxc-1-0-security-features](https://stgraber.org/2014/01/01/lxc-1-0-security-features/) и смотрим, что в принципе можно подарить контейнеру любое устройство. Смотрим (без разрешения автора, но не убирая ссылок. немного копипаста):
```
Большинство LXC шаблонов устанавливает только несколько записей
# Default cgroup limits
lxc.cgroup.devices.deny = a
## Allow any mknod (but not using the node)
lxc.cgroup.devices.allow = c *:* m
lxc.cgroup.devices.allow = b *:* m
## /dev/null and zero
lxc.cgroup.devices.allow = c 1:3 rwm
lxc.cgroup.devices.allow = c 1:5 rwm
## consoles
lxc.cgroup.devices.allow = c 5:0 rwm
lxc.cgroup.devices.allow = c 5:1 rwm
## /dev/{,u}random
lxc.cgroup.devices.allow = c 1:8 rwm
lxc.cgroup.devices.allow = c 1:9 rwm
## /dev/pts/*
lxc.cgroup.devices.allow = c 5:2 rwm
lxc.cgroup.devices.allow = c 136:* rwm
## rtc
lxc.cgroup.devices.allow = c 254:0 rm
## fuse
lxc.cgroup.devices.allow = c 10:229 rwm
## tun
lxc.cgroup.devices.allow = c 10:200 rwm
## full
lxc.cgroup.devices.allow = c 1:7 rwm
## hpet
lxc.cgroup.devices.allow = c 10:228 rwm
## kvm
lxc.cgroup.devices.allow = c 10:232 rwm
```
смотрим, коды устройств на dom0,
```
# ls -lah /dev/kvm
crw-rw-rw- 1 root kvm 10, 232 Июн 1 11:55 /dev/kvm
```
и далее, разрешаем все нужные нам устройства и создаем их в контейнере:
```
mknod /dev/net/tun c 10 200
mknod /dev/kvm c 10 232
```
запускаем систему и ставим всё что нам необходимо в нашем контейнере — не нарушив ничего у заказчика. По моему — круто!
Готовы ловить помидоры, но только после полного осознания глубины креатива ;-)
**Ссылки на материалы:**
* [stgraber.org/2014/01/01/lxc-1-0-security-features](https://stgraber.org/2014/01/01/lxc-1-0-security-features/)
* [vasilisc.com/lxc-1-0-security-features](http://vasilisc.com/lxc-1-0-security-features) | https://habr.com/ru/post/330016/ | null | ru | null |
# Построение множества Жюлиа
 Привет. Кипят страсти, конец года, сессии, дедлайны, новый год, а так же цензура проникает во все слои интернетов, что не может не печалить. [Хабр уже не торт](http://tjournal.ru/paper/deniskin). Просто хотелось написать, что я не согласен с таким подходом, но тогда бы меня просто забанили. Так что придется написать интересный контент. Хотя если забанят из-за предисловия к посту о множестве Жюлиа, ну что, тогда остатки торта стухли и шансов нет.
Итак, вернемся к теме поста. Я давно хотел немного больше узнать о комплексных числах, а не только то, что корень из минус единицы равен i. Особенно вызывали интерес фигуры имеющие фрактальную структуру, хотелось понять, что это значит, и как сделать такую визуализацию. Где то на полке стояла книжка по [ТФКП](http://ru.wikipedia.org/wiki/Комплексный_анализ), а так же закончился [курс по комплексному анализу на курсере](https://class.coursera.org/complexanalysis-001/), и появилось немного свободного от работы времени. Приступим.
#### Итерация функции
Перед тем как написать алгоритм, придется изучить несколько базовых понятий. Начнем мы с понятия итерация функции **f**. Введем следующее обозначение [**n**-ой итерации функции](http://en.wikipedia.org/wiki/Iterated_function) **f**:
* где знак **○** — [композиция функций](http://ru.wikipedia.org/wiki/Композиция_функций)
За нулевую итерацию принимается [тождественное отображение](http://ru.wikipedia.org/wiki/Тождественное_отображение):
Существует множество [теорем о неподвижных точках](http://en.wikipedia.org/wiki/Fixed-point_theorem) определенных типов отображений, вспомним что такое неподвижная точка некоторого отображения **g**, это решение следующего уравнения:
Аналогично, для итерации функции вводится [притягивающая точка](http://ru.wikipedia.org/wiki/Неподвижная_точка) — такая точка из области определения функции **f**, что последовательность значение итераций функции **f** сходится к некоторой неподвижной точке отображения **f**:
* где **y** — некоторая точка достаточно близкая к точке **x**
Множество всех **y**, удовлетворяющее предыдущему условию — называется предельным множеством точки **x** под действием итерации функции **f**.
Как правило, интерес представляет изучение последовательности функций образованных итерациями (подобную идею можно увидеть в [методе Ньютона](http://ru.wikipedia.org/wiki/Метод_Ньютона), искомое решение оказывается притягивающей неподвижной точкой построенного отображения, и потому может быть найдено как предел последовательности итераций.)
а так же последовательность значений вычисленных в некоторой начальной точке
Для комплексного мира визуализировать итеративную сходимость точки **y** к **x** под действием итерации функции **f** немного проблематично, все таки 4d, но для действительного мира картина всего 2d (красная траектория расходится, в то время как синяя сходится к неподвижной точке).
Итак, первый камушек, необходимый для понимания множества Жюлиа заложен, перейдем к следующему.
#### Квадратичный комплексный полином
Вообще множество Жюлиа строится для функции вида
* где **p** и **q** это комплексные полиномы
Мы же упростим задачу, и будем строить множество Жюлиа только для квадратичного полинома. Квадратичный комплексный полином в общем виде выглядит следующим образом:
Так же существует понятие унитарной (**a = 1**) центрированной (**b = 0**) формы квадратичного полинома
Введем следующее отображение **φ**, и найдем его обратное отображение:
Рассмотрим следующее выражение
Легко заметить, что последнее выражение напоминает квадратичный полином в общем виде **p(z)**, давайте найдем такое **c**, что бы привести полученное выражение к квадратичному полиному общего вида
Таким образом мы показали, что при вышеприведенной замене **c**, полином общего вида можно записать как
#### Поведение квадратичного полинома под действием итераций
Перейдем к третьему камушку базы для понимания множества Жюлиа. Рассмотрим вторую итерацию комплексного квадратичного полинома
Не трудно показать, что
И как раз вот тут мы объединяем все три пункта, давайте сформулируем вывод: *для того что бы исследовать поведение квадратичного полинома под действием итераций, достаточно исследовать его в унитарной центрированной форме, а не в общем виде*. А это реально круто, ведь в общем виде мы имеем целых три коэффициента, а в унитарной центрированной форме всего лишь один.
#### Хаотичное и нормальное поведение
Уже скоро можно будет дать определение множества Жюлиа. Мы будем рассматривать скорее интуитивные определения, нежели строго математические. Но сперва, рассмотрим понятие устойчивости. Решение некоторого дифференциального уравнения называется устойчивым, если поведение решения с условиями, близкими к начальным, *не сильно отличается* от поведения исходного решения. Не трудно догадаться, что вся соль во фразе *не сильно отличается*. Вообще выделяют различные типы устойчивости, например в определении множества Жюлиа участвует устойчивость по Ляпунову (это более ясное определение вытекает из [теоремы Монтеля о компактном семействе функций](http://ru.wikipedia.org/wiki/Теорема_Монтеля_о_компактном_семействе_функций)), но мы даже не будем вдаваться в суть различий устойчивостей, тут главное понять идею. Попробуем это проиллюстрировать. Для начала взглянем на интуитивное восприятие устойчивости, тут синяя и желтые траектории точек при небольшом изменении ведут себя почти одинаково, в то время как для красной траектории, небольшое изменение ведет совершенно в другую сторону.
Давайте рассмотрим следующий полином **f(z) = z2 — 1 + 0.213i**, и построим траекторию для 100 итераций при **z0 = 0.3 + 0.2i** и **z0 = 0.31 + 0.2i**
В этом примере вы видите, что небольшое изменение в начальном условии вылилось в расхождение траекторий, такое поведение мы назовем хаотичным в некоторой окрестности начальной точки, т.е. поведение сильно зависит от небольших изменений в начальных условиях. В то время как поведение при котором сохраняется устойчивость, т.е. небольшие изменения в начальных условиях не сильно влияют на поведение в целом, мы будем называть нормальным, как в следующем примере. Рассмотрим следующий полином **f(z) = z2 — 1 + 0.2i** (всего лишь чуть изменили константу **c**), и построим траекторию для 100 итераций при **z0 = 0.3 + 0.2i** и **z0 = 0.31 + 0.2i**
#### Множества Фату, Жюлиа и Мандельброта
* **Множеством Фату** полинома **f(z) = z2 + c** называется такое подмножество множества комплексных чисел, для каждой точки которого, поведение функции под действием итераций является **нормальным**, т.е. траектория точек генерируемая итерациями, не сильно изменяется при изменении начальных условий в некоторой небольшой окрестности начальной точки. Обозначается **F(f)**.
* **Множеством Жюлиа** полинома **f(z) = z2 + c** соответственно называется такое подмножество множества комплексных чисел, для каждой точки которого, поведение функции под действием итераций является **хаотичным**, т.е. небольшие изменения в начальных условиях в некоторой небольшой окрестности начальной точки, значительно влияют на траекторию. Обозначается **J(f)**
* **Множество Мандельброта** — это такое множество параметров **c** полинома **f(z) = z2 + c**, для которого множества Жюлиа **[связно](http://ru.wikipedia.org/wiki/Связное_пространство)**.
#### Бассейн аттрактора
Итак мы узнали смысл множества Жюлиа, можно приступить к алгоритму построения такого множества. Но и для этого, придется сперва ввести некоторые другие определения.
* [Аттрактором](http://en.wikipedia.org/wiki/Attractor) называется множество состояний динамической системы, в направлении которых развивается система с течением времени. В нашем случае можно понимать под аттрактором подмножество неподвижных точек к которым сходятся последовательности итераций функции независимо от начальных условий.
* **Бассейном аттрактора** точки **z** функции **f** называется подмножество точек из окрестности **z** (обозначаемая как **A(z)**), такое что любая траектория начатая в одной из этих точек сходится к точке **z**
* Бассейном аттрактора к бесконечности **A(∞)** будем называть множество тех точек **z**, для которых траектории уходят в бесконечность, т.е. другими словами не сходятся к какой то неподвижной точке, а так же не осциллируют между двумя или более периодическими точками (неподвижная точка — это периодическая точка с периодом равным единице).
Рассмотрим **A(∞)** в контексте наших рассуждений для некоторого полинома **f(z) = z2 + c**
Оказывается существует следующая теорема. *Множество **A(∞)** (в вышеописанном контексте) является [открытым](http://ru.wikipedia.org/wiki/Открытое_множество), [связным](http://ru.wikipedia.org/wiki/Связное_пространство) и [неограниченным](http://ru.wikipedia.org/wiki/Ограниченное множество). Оно полностью содержится во **множестве Фату**. **Множество Жюлиа** совпадает с [границей](http://ru.wikipedia.org/wiki/Граница_(топология)) **A(∞)**, которая является [замкнутым](http://ru.wikipedia.org/wiki/Замкнутое_множество) и [ограниченным](http://ru.wikipedia.org/wiki/Ограниченное множество) подмножеством всех комплексных чисел.*
#### Построение множества Жюлиа
Напоминаю, что мы напишем алгоритм для построения множества Жюлиа **квадратичной динамики**, а не любой функции. Итак мы узнали что **множество Жюлиа** совпадает с [границей](http://ru.wikipedia.org/wiki/Граница_(топология)) **A(∞)**, которая является [замкнутым](http://ru.wikipedia.org/wiki/Замкнутое_множество) и [ограниченным](http://ru.wikipedia.org/wiki/Ограниченное множество) подмножеством всех комплексных чисел, т.е. множество Жюлиа тоже замкнуто и ограничено. Обозначим следующим образом то подмножество комплексных чисел, которое генерируется итерациями функции **f** и остается ограниченным. Назовем такое множество **заполненным множеством Жюлиа**:
И последняя теорема которая нам понадобится звучит следующим образом:
* пусть дан некоторый квадратичный полином вида **f(z) = z2 + c**
* обозначим 
* тогда для некоторой точки  и **n > 0** выполняется следующие условие
* 
* т.е. если модуль **n**-ой итерации больше **R**, то итерации функции **f** расходятся, это эквивалентно тому, что точка **z0** входит в бассейн аттрактора к бесконечности, откуда следует, что **z0** не является точкой заполненного множества Жюлиа
Помимо самого алгоритма, из этой теоремы можно сделать вывод, что все множество Жюлиа находится внутри шара радиуса **R** с центром в начале координат.
PS: примерно тут любители дизайна и золотых сечений, мистики и оккультики, заметят, что при **f(z) = z2 + 1**, порог R равен золотому сечению **о\_0**
#### Алгоритм
1. Выбираем **с** для задания полинома **f(z) = z2 + с**
2. Вычисляем **R** для заданного полинома **f(z) = z2 + с**
3. Выбираем параметр maxIter для обозначения максимальной итерации, очевидно чем он выше, тем лучше точность, тем медленнее алгоритм
4. Генерируем массив цветов, всего maxIter штук, скажем от менее яркого к более яркому, мы будем обозначать цветом, то на сколько далеко точка расположена от множества Жюлиа
5. Для каждой точки вычисляем является ли она частью заполненного множества Жюлиа или нет, а так же номер итерации на которой порог был превышен
6. если **|z| > R** то используем первый цвет, далее используем тот свет, на каком номере итерации был превышен порог
**Процедура генерации множества Жюлиа**
```
///
/// Generate bmp with Julia set
///
/// parameter of square dynamics
/// width of bmp
/// height of bmp
/// max iterations of function
/// window in complex plane
/// window in complex plane
/// window in complex plane
/// window in complex plane
///
static XBitmap PlotJuliaSet(ComplexNumber c, int w, int h, int maxIter,
double xMin = Double.NaN, double yMin = Double.NaN, double xMax = Double.NaN, double yMax = Double.NaN)
{
double r = CalculateR(c);
if (Double.IsNaN(xMin) || Double.IsNaN(xMax) || Double.IsNaN(yMin) || Double.IsNaN(yMax))
{
xMin = -r;
yMin = -r;
xMax = r;
yMax = r;
}
Logger.Instance.Log("R = " + r);
double xStep = Math.Abs(xMax - xMin) / w;
double yStep = Math.Abs(yMax - yMin) / h;
XBitmap bmp = new XBitmap(w, h);
IDictionary> xyIdx = new Dictionary>();
int maxIdx = 0;
for (int i = 0; i < w; i++)
{
xyIdx.Add(i, new Dictionary());
for (int j = 0; j < h; j++)
{
double x = xMin + i \* xStep;
double y = yMin + j \* yStep;
ComplexNumber z = new ComplexNumber(x, y);
IList zIter = SqPolyIteration(z, c, maxIter, r);
int idx = zIter.Count - 1;
if (maxIdx < idx)
{
maxIdx = idx;
}
xyIdx[i].Add(j, idx);
}
}
for (int i = 0; i < w; i++)
{
for (int j = 0; j < h; j++)
{
int idx = xyIdx[i][j];
double x = xMin + i \* xStep;
double y = yMin + j \* yStep;
ComplexNumber z = new ComplexNumber(x, y);
bmp.SetPixel(w - i - 1, j, ComplexHeatMap(idx, 0, maxIdx, z, r));
}
}
return bmp;
}
private static IList SqPolyIteration(ComplexNumber z0, ComplexNumber c, int n, double r = 0)
{
IList res = new List();
res.Add(z0);
for (int i = 0; i < n; i++)
{
if (r > 0)
{
if (res.Last().Mod > r)
{
break;
}
}
res.Add(res.Last() \* res.Last() + c);
}
return res;
}
private static double CalculateR(ComplexNumber c)
{
return (1 + Math.Sqrt(1 + 4\*c.Mod))/2;
}
public static Color ComplexHeatMap(decimal value, decimal min, decimal max, ComplexNumber z, double r)
{
decimal val = (value - min) / (max - min);
return Color.FromArgb(
255,
Convert.ToByte(255 \* val),
Convert.ToByte(255 \* (1 - val)),
Convert.ToByte(255 \* (z.Mod / r > 1 ? 1 : z.Mod / r))
);
}
```
#### Результаты
Вот несколько в картинок 5к на 5к, сделанных с помощью этой функции
* [**f(z) = z2 — 0.8 + 0.156i**](https://drive.google.com/file/d/0B4bl7YMqDnViR01xbGY5UW9GbVU/edit?usp=sharing)
* [**f(z) = z2 + 0.285 + 0.01i**](https://drive.google.com/file/d/0B4bl7YMqDnViMEpIUkJJaHV6YUE/edit?usp=sharing)
* [**f(z) = z2 — 0.0085 + 0.71i**](https://drive.google.com/file/d/0B4bl7YMqDnVicnNiU21GcW1CQm8/edit?usp=sharing)
А теперь давайте позумим множество Жюлиа для полинома **f(z) = z2 — 0.74543 + 0.11301i**, всё множество содержится в шаре радиуса **1.50197192317588**.
Вот примерно на этой картинке кажется, что предел точности достигнут, и все красные элементы принадлежат множеству Жюлиа. Но не тут то было, увеличиваем параметр maxIter, и получаем еще более точное приближение. В общем продолжать можно до бесконечности. Без шуток -)
 | https://habr.com/ru/post/206516/ | null | ru | null |
# Уроки компьютерного зрения на Python + OpenCV с самых азов
[**Оглавление.**](https://habr.com/ru/post/688316/)
В этом цикле уроков я расскажу о том, как использовать библиотеку OpenCV в языке Python. Но для начала несколько слов о самом компьютерном зрении. Как компьютер вообще видит? Если подключить к нему видеокамеру, это еще не значит, что он будет видеть. Мы получим просто набор нулей и единиц. А человек видит что-то осмысленное. Как же из этих нулей и единиц извлечь что-то осмысленно? В этом и состоит задача компьютерного зрения.
Как правило, анализ изображения алгоритмами компьютерного зрения проходит следующие этапы (но некоторых этапов может и не быть):
**1. Предобработка изображения.** На этом этапе может происходить улучшения качества изображения, такое как увеличение контрастности, повышение резкости или наоборот, размытие изображения, чтобы удалить из него шумы и мелкие незначительные детали. Все это нужно для того, чтобы в дальнейшем было легче производить анализ изображения.
**2. Промежуточная фильтрация.** На этом этапе к изображению применяют различные фильтры, для того, чтобы обозначить на изображения области интереса или облегчить работу специальным алгоритмам анализа изображения.
**3. Выявление специальных признаков (фич).** Это может быть выделение особых точек, выделение контуров или еще каких-либо признаков.
**4. Высокоуровневый анализ.** На этом этапе по найденным признакам на изображения определяться конкретные объекты, и, как правило, их координаты. Так же на этом этапе может происходить сегментация либо какая-то иная высокоуровневая обработка.
Ну а теперь перейдем к делу. Мы рассмотрим работу с Python + OpenCV в среде PyCharm. Сначала нам надо установить OpenCV. Для этого идем в Settings:
Далее в ProjectInterpreter и там жмем на плюсик:
Ищем там opencv и устанавливаем его:
Теперь напишем наш «Hello, World» — программу, которая отобразит картинку:
```
import cv2
my_photo = cv2.imread('MyPhoto.jpg')
cv2.imshow('MyPhoto', my_photo)
cv2.waitKey(0)
cv2.destroyAllWindows()
```
Вот такое вот окно откроет данная программа:
Что делает программа? Она загружает изображение из файла, отображает его и ждет нажатие клавиши ESC для завершения работы.
Давайте попробуем что-нибудь сделать с этим изображением. Например, можно изменить его размер. Допустим, мы хотим сделать изображение шириной 200. Для этого вычислим его высоту, и применим эти данные для масштабирования:
```
import cv2
my_photo = cv2.imread('MyPhoto.jpg')
cv2.imshow('MyPhoto', my_photo)
#Подготовим новые размеры
final_wide = 200
r = float(final_wide) / my_photo.shape[1]
dim = (final_wide, int(my_photo.shape[0] * r))
# уменьшаем изображение до подготовленных размеров
resized = cv2.resize(my_photo, dim, interpolation = cv2.INTER_AREA)
cv2.imshow("Resized image", resized)
cv2.waitKey(0)
cv2.destroyAllWindows()
```
Вот что у нас получилось:
Часто для облегчения анализа изображения требуется сделать картинку черно-белой. Один из способов – это загрузить картинку сразу в черно-белом цветом пространстве:
```
import cv2
img = cv2.imread('MyPhoto.jpg', cv2.IMREAD_GRAYSCALE)
cv2.imshow('MyPhoto', img)
cv2.waitKey(0)
cv2.destroyAllWindows()
```
Если нужно преобразовать уже загруженную картинку, то можно воспользоваться функцией cvtColor, которая преобразует изображение из одного цветового пространства в другое:
```
import cv2
my_photo = cv2.imread('MyPhoto.jpg')
gray = cv2.cvtColor(my_photo, cv2.COLOR_BGR2GRAY)
cv2.imshow('MyPhoto', gray)
cv2.waitKey(0)
cv2.destroyAllWindows()
```
Вот как это будет выглядеть:
Итак, подытожим.
Мы научились устанавливать OpenCV, загружать из файла и отображать изображение, а так же делать в нем простейшие преобразования, такие как масштабирования и конвертацию цветного изображения в черно белое. Если данный урок «зайдет» то будет продолжение. | https://habr.com/ru/post/540166/ | null | ru | null |
# React Native с колокольни Android разработки часть 2
Свою прошлую [статью](https://habrahabr.ru/post/329380/) я написал спустя несколько дней, после того, как я вообще начал ковыряться в react native, до этого имея опыт только в нативной разработке под android и iOS. Спустя это время я уже успел поработать над реальным react native проектом. И теперь хочу осветить все очевидные и неочевидные моменты с которыми я столкнулся в момент работы с реальным проектом. Всем заинтересованным под кат.
Инструменты
-----------
Еще раз хочу осветить тему рабочих инструментов. React native еще не очень близок к версии, хотя бы, 1.0, чему и причина отсутствия полностью рабочего и заточенного под этот продукт IDE. Хотя, внезапно, я наткнулся на это: [Deco IDE](https://www.decoide.org). Да, это самая настоящая IDE (только под macOS по понятным причинам), да еще и [купленная](https://www.decosoftware.com/#announcement) airbnb. Но не все так радужно как оказалось. Да, тут можно «программировать мышкой» просто перетаскивая компоненты в код. Опять же, есть список компонентов, не нужно каждый раз лезть на оф. сайт, чтобы узнать, а какой компонент еще там есть. Так же можно запустить проект буквально 1 тыком (правда, только iOS, с андроидом всегда проблемы). Но на этом все фишки и кончаются. Тут нету ни быстрых переходов к компонентам по клику с зажатым cmd, нету даже адекватного линтера и автодополнения. По функционалу кодинга — это простой блокнот, который только не закрытый тэг сможет подсветить. Но теперь этим инструментом занята крупная компания, надеюсь на его скорое развитие.
В большинстве видео про react native, а так же в скриншотах различных статей я везде видел [VS code](https://code.visualstudio.com). Штука действительно неплохая, спокойно подцепляется eslinter как плагин, можно подцепить flow, есть автокомплиты и даже переходы к компонентам. Есть встроенный git и даже интегрированный терминал. И я бы тоже его использовал, но есть огромный для меня минус — по дефолту каждый открытый файл открывается в одной вкладке, как бы заменяя предыдущий. Чтобы открыть 2 вкладки с разными файлами, нужно начать редактирование в файле, затем открывать другой, который уже и откроется во второй вкладке. Если нужно просто быстро просмотреть 2-3 разных файла, ~~обивку на стуле приходится менять~~ это приносит некий дискомфорт.
Поэтому я все так же остановился на [Nuclide](https://nuclide.io), правда, подцепив [flow](https://nuclide.io/docs/languages/flow/), что сильно улучшает автокомплит, добавляет быстрые переходу к компонентам по клику, плюс все фишки с типизацией. Про красивые и удобные запуски проектов в 1 клик пока что приходится забыть.
Работа с камерой, картой и другими сложными вещами
--------------------------------------------------
Это, пожалуй, наиболее интересный вопрос для всех. Плохая новость — дефолтных компонентов для камеры и карты нету. Нужно использовать нативный код. Хорошая новость — все уже давно сделано до нас:
* [Дико крутые карты](https://github.com/airbnb/react-native-maps) под авторством airbnb. Использовал лично, все замечательно работает как на iOS, так и на андроид, так же отлично кастомизируется.
* [Камера](https://github.com/lwansbrough/react-native-camera) уже тоже есть. Хотя, лично не пробовал, небыло необходимости, хотя и любопытно.
* [В геопозицию](https://facebook.github.io/react-native/docs/geolocation.html), благо, умеет из коробки.
Вообще, уже есть куча рабочих компонентов, нужно просто погуглить. Но можно написать и самому.
Рабочий процесс
---------------
У react native есть только 1 проблема — ~~андроид~~ проблемы с андроидом. Уж не знаю, проблемы ли это системы или разработчиков, что клали болт на андроид, но с ним вечно какие-то странные косяки.
Самый странный случай: Date переведенный в строку формата: «YYYY-MM-DD HH:mm:ss» имеет разную длину символов на iOS и android, догадайтесь на какой платформе лишний пробел? Что приводит просто к лютой парное, вот казалось бы, код на чистом js, все работает замечательно на iOS, а на андроиде что-то может пойти не так. Поэтому ВСЕГДА нужно проверят приложение на обеих платформах после ЛЮБОГО изменения кода, никогда не знаешь в какую проблему это может вылиться.
На самом деле подобная проблема была единична для меня, почему-то криво работает Date на андроиде, а вот momentJS прекрасно. Так что сразу используйте последнее. А вот с версткой проблемы другого характера.
Во-первых, андроид вообще не умеет в тени, что указываются в стилях. Для него есть отдельный параметр — 'elevation', но только и всего. Цвет тени, радиус, прозрачность — все это проходит мимо андроида.
Во-вторых, разрешение экранов. У яблофонов просто огромные разрешения, особенно в плюсах, от чего, бывают проблемы, когда выставляешь кнопки с нужными размерами шрифтов, на iOS все смотрится хорошо, на андроиде все слипается — экран маловат будет. Благо, react native дает возможность определить платформу, на которой запустилось приложение, и от этого изменять что-то в коде, например, стили.
Что касается самого процесса разработки, то тут сложно описать то чувство свободы, которое ты обретаешь, после нативной разработки под android. Android SDK дает нам инструменты, предназначенные для чего-то конкретного, отойти от которых никак нельзя. Вот было придумано, что должна быть активити, в которой подцепляется класс к layout, и хоть что ты делай, а активити быть должна, даже сам гугл с этим ничего поделать не может. Вот дали они нам data binding, и вот используя эту библиотеку активити в 99% случаев используется как костыль, просто чтобы подцепить layout и ViewModel, попутно передав Model, хотя мы в layout'е уже явно указали и model и ViewModel. Абсолютно никакой логики в этом случае тут нету, а активити есть. Для передачи информации нужен Intent, а он без проблем может передавать только простые типы, а если хочется передать объект, то все, здравствуй Parcelable.
И таких примеров очень много. В случае с react native есть только… JavaScript и все. Ты сам решаешь как сделать тот или иной элемент. Именно поэтому для навигации можно использовать аж 3 разных библиотеки:
* [Одна](https://github.com/wix/react-native-navigation)
* [Вторая](https://github.com/aksonov/react-native-router-flux)
* [Третья](https://github.com/react-community/react-navigation)
Да и вообще, любая задача может быть решена как угодно (ну, почти). И это самое интересное в реактиве.
Компоненты
----------
Отдельного упоминания заслуживают компоненты. Для ребят с веба, это привычный инструмент, а вот для нас, ребят с мобилок — это просто серебряная пуля.
Тут у нас 3 разные кнопки. На самом деле не разные, это один компонент. Понимаете масштаб крутизны компонентов? Тут от слова «совсем» можно забыть про копипасту в верстке. Да, в андроиде есть стили, которые теоретически, должны избавить нас от копипасты. Но ведь они применяются к чистым компонентам. Да, я могу задать стиль button, но что бы сделать кнопку как на картинке выше, одним button в андроиде не обойдешься. Это целый отдельный layout, где будет и TextView и ImageView и у всего этого, а так же у layout будут свои параметры стиля. И все 3 кнопки будут отличаться еще и различным количеством этих компонентов, где-то нету картинок, где-то 2 текста и т.п… Другими словами, сделать все эти 3 кнопки на андроиде не сверстав их 3 раза никак не получится. Ну а как получается это делать на реакте? Тут есть 3 щепотки магии:
1. Props
2. Отображение только тех элементов, что существуют
3. Наложение стилей
Подробнее обо всем.
В андроиде мы сначала создаем компонент в layout'е, затем находим его по ID'шнику в активити и передаем какие-то параметры, например, текст меняем. Это работает, если мы заранее знаем что хотим отобразить. В реактиве мы же указываем какой нам создать компонент с НУЖНЫМИ нами параметрами. В чем соль? В props мы можем передавать ВСЕ ЧТО УГОДНО, без каких либо проблем, начиная от простых типов, заканчивая объектами. Допустим, нам нужна еще 1 кнопка, такая же как по середине, только с другой стрелочкой. В андроиде мы бежим рисовать уже 4-ю кнопку, а тут же мы просто передаем через props другую иконку.
Но бОльшая магия твориться вот тут:
```
{true && Я существую}
{false && Я НЕ существую}
```
Смысл в том, что так можно не отображать несуществующие объекты. Мы ведь используем JS с динамической типизацией, и ей можно удобно пользоваться для себя, например:
```
const text = this.props.text;
{text && {text}
```
Если мы передали в props параметр text, то компонент его отрисует, а если не передали, то не отрисует, ибо зачем? Стоит еще раз акцентировать внимание на динамическую типизацию. С текстом все хорошо, текст есть — true, текста нету — false, тоже и с объектами. А вот с числами беда, отправите 0 — JS будет думать что это false… Для чисел лучше более явно проверять тип.
Начинает доходить логика? Мы делаем компонент, который учитывает все возможные варианты того, что в нем может находится, оборачивая их в конструкцию, что я представил выше.
И тут может возникнуть другая проблема — слишком большой текст, слишком большая картинка и прочее могут сломать внешний вид компонента. Тут нам на помощь приходит пункт номер 3:
```
{this.props.text}
```
Стиль мы определяем как массив стилей. Что это значит? Это значит, что если мы НЕ передали в props свой стиль, то компонент будет в дефолтном, который мы определили заранее. Но что, если мы передадим в кастомный стиль 1 параметр, допустим, отступ сверху? И этот компонент будет иметь дефолтный стиль плюс отступ сверху. Смысл в том, что всегда ПОЛНОСТЬЮ применяется дефолтный стиль, только в нем заменяются лишь те параметры, которые мы передаем в кастомном стиле. Т.е. если мы хотим только изменить цвет текста — не беда, размеры, отступы и прочие радости не слетят. А если нам какой-то параметр в стиле не нужен, мы передаем в кастомном стиле этот параметр со значением null.
Заключение
----------
Еще можно упомянуть про работу с данными через redux, но это отдельная философия, рассчитанная на полноразмерные статьи. Скажу за себя, после нативной разработки я прошел все 5 стадий принятия неизбежного, когда работал с redux. Но потом я втянулся и очень зауважал такой подход.
Самый главный вопрос для кого react native? Да для всех. Делая продукт, нужно держать 2 команды разрабов — для iOS и android. Тут же хватит и одной. Во-первых, это тупо дешевле, нужно в 2 раза меньше людей, а во-вторых, удобно — появился баг, поправил сразу на 2 платформы. И серьезные ребята тоже начали [втягиваться](https://facebook.github.io/react-native/showcase.html). Тут уже не только фейсбук и инстаграмм. Airbnb, walmart, testa, думаю, эти ребята что-то знают)
Да и потом, проект еще даже не близок к релизу версии 1.0, а им уже заинтересованны многие именитые ребята, которые [собираются вместе](http://facebook.github.io/react-native/blog/2017/06/21/react-native-monthly-1.html) для развития проекта. У нас есть уникальный шанс сесть не на уезжающий поезд, а на проезд, который еще даже не доехал до станции. Все кто овладел этим инструментом (особенно те, у кого есть опыт нативной разработки под мобилки) еще до массового релиза версии 1.0, будут иметь огромное преимущество перед другими. | https://habr.com/ru/post/333518/ | null | ru | null |
# Wix toolset: не так страшен черт, как Windows installer
В статье я хотел бы поделиться своим опытом написания инсталлятора для Windows с использованием инструмента **Windows Installer XML Toolset** (далее - **Wix**). К сожалению, несмотря на всю мощь данного инструмента, его использование сильно осложняется куцей документацией, старенькими кукбуками, вялыми ветками форумов и вытеснением *.msi* и *.exe* пакетов контейнеризацией. Однако, сегодня продолжают активно развиваться и создаваться программные продукты требующие развертывания на виндовой машине с использованием *традицонных* установочных пакетов.
Прежде, чем мы преступим к написанию инсталлятора нужно решить, что мы будем устанавливать. По большому счету, инструментарий Wix *не ограничивает* разработчика в технологиях на которых должен быть написан продукт, который будет развернут на машине пользователя. Главное условие, чтобы на машине пользователя была установлена соответствующая версия Windows с пакетами, необходимыми для запуска вашего продукта (кстати, wix позволяет в установочный пакет запихнуть в том числе и необходимые компоненты для настройки окружения, но об этом поговорим позже).
Для нашего инсталлятора предлагаю использовать дефолтный проект *Blazor*: с одной стороны нам не потребуется писать код устанавливаемого проекта, а с другой у нас будет достаточно высокий потенциал для костылизации, чтобы изучить возможности Wix toolset.
Теория
------
Прежде чем приступить к практической части предлагаю ускоренный ликбез по технологии *Windows installer* и *wix toolset,* что поможет читателю понять мотивы, которыми руководствуются команды разработчиков вставая на путь, вымощенный граблями.
Начнем с того, что *Wix toolset* – это набор инструментов, позволяющий создавать установочные пакеты *Windows installer* на основе *.xml-описания*, который включает в себя консольные утилиты, плагин для работы *Visual Studio* и *Rider*, несколько тем оформления инсталлятора (глобально они отличаются «глубиной» диалогов, определяющей свободу пользователя в процессе установки), а также средства создания бутстрапера (пожалуй, дословный перевод «установщик» в данном случае не особо применим).
*Windows installer*, в свою очередь, представляет собой подсистему Windows для развертывания программного обеспечения с использованием установочных пакетов *.msi* *(Microsoft Installer)*. Не погружаясь в историю создания и эволюции данной подсистемы (кому интересно, можете поискать информацию о инсталляторе с кодовым названием *Darwin*) предлагаю сразу перейти к ее функционалу.
Так, ключевую ценность данной подсистемы представляет высокая гибкость процесса установки, обновления и удаления программ, что обеспечивается:
* Возможностью отката на любом этапе установки включая апгрейд и *удаление* софта
* Предоставлением доступа к работе с *реестрами* включая чтение и удаление записей
* *Гибкостью* работы с *правами* *доступа* при установке софта
* Обеспечением возможности *кастомизации* *интерфейса* установки, включая возможность добавления рекламы
* Предоставлением доступа к ресурсам командной строки и возможности *запуска скриптов* на разных этапах работы инсталлятора
* Наличием *специализированного ПО*, предоставляемого *Microsoft для устранения проблем*, возникших после запуска инсталляционного пакета с уязвимостью (например, если ошибка приводит к невозможности удаления установленного софта)
Сам инсталлятор представляет собой файл с расширением *.msi* внутри которого располагается реляционная база данных, описывающая логику установки программного обеспечения, а также хранит данные, необходимые для развертывания приложения. Для работы с инсталляционными пакетами вам потребуется установить [Windows SDK](https://developer.microsoft.com/ru-ru/windows/downloads/windows-sdk/). Основным инструментом для взаимодействия с файлами .msi является *Orca* – программа, позволяющая открывать, редактировать и создавать БД инсталляционных пакетов. Для ее установки вам потребуется перейти в директорию *C:\Program Files (x86)\Windows Kits\10\bin\10.0.22000.0\x86* после установки Windows SDK.
Давайте посмотрим на пример содержимого инсталляционного пакета, который мы с вами создадим с помощью WIX для проекта Blazor. Его содержимое выглядит так:
В приведенном примере инсталлятор содержит 35 таблиц. Это число не является фиксированным. Только Orca предлагает включение до *97 шаблонов таблиц*, помимо которых можно создавать пользовательские.
Разберем по пунктам:
* в колонке *File* хранится *ID* файла, который будет установлен в систему. Он выполняет роль *первичного ключа* для доступа и связывает сущности из таблицы *MsiFileHash* и *Component*
* В *Component\_* лежит значение соответствующее полю *KeyPath* из таблицы *Component*, которое служит для реализации функционала, связанного с восстановлением и обновлением ПО средствами *WindowsInstaller*
* В *FileName* хранится непосредственно имя файла
* *FileSize*, *Version* и *Language* берутся из метаданных устанавливаемого файла
* *Atributes* – свойства устанавливаемого файла, определяющие его доступность для пользователей, а также поведение при обновлении, восстановлении и удалении продукта. Подробнее можно ознакомиться по [ссылке](https://docs.microsoft.com/en-us/windows/win32/msi/file-table)
* *Sequence* определяет положение файла в инсталляторе и должен соответствовать его номеру в *cabinet-файле*.
Если, вы еще не сильно утомились сухой теорией, то давайте посмотрим еще на одну ключевую таблицу – *Component*:
В этой таблице описаны компоненты: .
* В колонке *Component* лежит название компонента, которое должно быть уникальным. Оно может быть создано как разработчиком, так и средствами автоматизации. Главное, что с помощью этого значения компонент связывается с файлом, который будет в него завернут.
* *ComponentId – GUID*, который должен быть сгенерирован для каждого компонента. Фактически это первичный ключ в таблице компонентов.
* Колонка *Directory\_* связывает компонент с виртуальной директорией, которая будет ассоциирована с местом установки конкретного компонента.
Думаю, на этом кратенький рассказ о внутреннем устройстве базы данных пакета .msi можно закончить. Конечно, кроме файлов, компонентов и папок, база данных инсталлятора включает описание *опций (feature)*, *действий (action)*, *UI* и пр. При наличии интереса у читателей, готов подготовить более подробный обзор структуры .msi пакетов.
Практика
--------
Для того, чтобы упростить разработку инсталляционных пакетов и облегчить дальнейшую поддержку были разработаны различные инструменты, позволяющие *визуализировать* и *автоматизировать* некоторые рутинные процессы. К таким продуктам, например, относятся *InstallShield*, *InnoSetup (не позволяет создавать .msi-файлы - только .exe)* и *AdvancedInstaller*. Несмотря на удобство использования, данные продукты являются *платными* (стоимость некоторых продуктов довольно кусачая за исключением Inno Setup - он бесплатный), не имеют открытых репозиториев или создают сложности при корпоративной разработке при мерже проектов. Поэтому наиболее очевидным выбором для большинства интерпрайз-проектов является использование *The Windows Installer XML (WiX) toolset*.
Для начала работы с этим инструментом вам необходимо произвести его установку. Перейдите по [ссылке](https://wixtoolset.org/releases/) и скачайте и установите WiX Toolset build tools и WiX Toolset Visual Studio Extension (в соответствии с используемой вами версией Visual Studio). Также, есть расширение для Rider – его можно найти в маркете IDE.
После установки компонентов Wix предлагаю перейти в Visual Studio и приступить к созданию проекта Blazor для которого мы будем писать инсталлятор.
Создадим проект Blazor Wasm и опубликуем его File -> New Project -> Blazor WebAssambly App. Назовем проект BlazorAppForInstaller.
На следующем шаге обязательно поставьте галочку ASP.NET Core hosted и выберите .Net 6.0.
После того как проект был создан опубликуем его:
Щелкнуть правой кнопкой мыши по BlazorAppForInstaller.Server -> Publish -> Target: Folder -> Finish.
Проект должен быть опубликован *в указанную вами папку* (в моем случае, это *~\BlazorAppForInstaller\Server\bin\Release\net6.0\publish\):* содержимое этой директории мы и будем упаковывать в инсталлятор.
Создадим проект Wix InstallerForBlazorAppЩелкнуть правой кнопкой мыши по названию решения Add -> New project
В поиске вбиваем Wix
В результатах поиска выбираем Setup Project for Wix v3 и нажимаем Next
В поле Project name вводим названием. В моем случае это InstallerForBlazorApp. Щелкаем по кнопке Create.
Настройка проекта
-----------------
Для сборки инсталлятора необходимо описать *компоненты* (то есть файлы установки).
Если бы мы имели дело с простым проектом, состоящим из десятка файла, то вполне допустимо их описать вручную. Однако, когда речь заходит о суровой интерпрайз разработке или просто о больших проектах, включающих кучу файлов (особенно это касается веба) довольно сложно (а зачастую невозможно) становится следить за добавлением или удалением файлов. Именно поэтому, мы воспользуемся *консольной* утилитой *Harvest Tool* (*heat.exe*), который можно найти в директории ~/*WiX Toolset v3.11\bin* (по умолчанию, должна быть создана при установке в C:/Program Files (x86)). Подробно ознакомиться с возможностями *Heat.exe* можно в официальной документации <https://wixtoolset.org/documentation/manual/v3/overview/heat.html>
Я предлагаю сделать запуск *heat.exe* частью сборки проекта, чтобы сэкономить силы в процессе разработки – благо проекты Wix позволяют интегрировать генерацию описания непосредственно в файл проекта *.wixproj*.
Щелкаем правой кнопкой мыши по проекту инсталлятора -> *Add Reference* — открываем папку, в которую был установлен WiX, подкаталог bin, файл WixUtilExtension.dll
С использованием любого текстового редактора откройте файл *InstallerForBlazorApp.wixproj* и вставьте следующий кусок кода перед закрывающимся тегом
```
BasePath=..\..\BlazorAppForInstaller\BlazorAppForInstaller\Server\bin\Release\net6.0\publish;
```
Как вы видите, код помещен внутрь тега описывающий действия, которые должны быть выполнены непосредственно перед сборкой инсталлятора. К таким действиям относится *объявление констант препроцессора*, к которым можно будет обращаться до этапа сборки проекта. Так, переменная (да, это константа, но нейминг Wix периодически противоречит самому себе) *BasePath* используется для обозначения пути проекта, который будет упакован в инсталлятор. Настоятельно рекомендую использовать относительные пути настолько насколько это возможно.
Далее, с помощью тега и его свойств мы вызываем утилиту Heat.exe и передаем ей необходимые аргументы:
* `OutputFile="ComponentsGenerated.wxs"` – путь до файла, в котором хранятся компоненты для установки
* `DirectoryRefId="INSTALLFOLDER"` – ссылка на папку в которую будет произведена установка приложения (по сути это переменная в которую будет записан путь до директории установки)
* `ComponentGroupName="PublishedComponents"` – наименование группы компонентов, которые были сгенерированы. Используется как алиас для множества компонентов и является абстракцией, существующей исключительно в рамках проект Wix. Когда инсталлятор будет скомпилирован, то в таблицах .msi файла вы не найдете сущности соответствующей группе компонентов
* `AutoGenerateGuids="false"` и `GenerateGuidsNow="true"` – настройка генерирации GUID для компонентов в момент вызова утилиты Heat. Такая конфигурация заставляет Heat создать для каждого компонента уникальный GUID в момент запуска таски, т.е. на этапе сборки проекта. Такой подход минимизирует количество ошибок, возникающих при компиляции проекта Wix.
* `ToolPath="$(WixToolPath)"` – путь до директории с установленным Wix Toolset. Рекомендую использовать переменную окружения WixToolPath, которая создается при установке Wix. По большому счету, прописывать вручную путь придется только в том случае, если вы планируете использовать Wix toolset без установки через стандартный инсталлятор.
* `PreprocessorVariable="var.BasePath"` – переменная препроцессора, которая используется в качестве части пути (указывает на директорию) до файла-компонента. Мы ее объявили внутри тега
* `RunAsSeparateProcess="$(RunWixToolsOutOfProc)"`– обязательно указывайте этот атрибут, если работаете в Visual Studio 2022 и собираете 64-битный проект. В противном случае Visual Studio будет закрываться при каждой попытке построить проект. Эту проблему обсуждали [здесь](https://github.com/wixtoolset/issues/issues/6636)
* `SuppressRootDirectory="true"` – необходим для избежания дублирования родительских папок компонента.
* `SuppressCom="true", SuppressFragments="true"` и `SuppressRegistry="true"` – несмотря на то, что очень не велика вероятность, что в вашем проекте окажутся COM объекты, файлы реестров и фрагменты установщика лежащие в одной папке с основным проектом, рекомендуется дополнительно запретить включать такие файлы в процесс создания описания компонентов из-за высокой вероятности возникновения ошибок. Если же, у вас есть необходимость включения таких файлов в проект инсталлятора, рекомендуется добавить отдельное описание таких компонентов.
После внесенных изменений InstallerForBlazorApp.wixproj должен выглядеть так
```
xml version="1.0" encoding="utf-8"?
Debug
x64
3.10
6f99cf2a-a8d3-4f08-a4e1-cd86ea9c9785
2.0
InstallerForBlazorApp
Package
bin\$(Configuration)\
obj\$(Configuration)\
Debug
bin\$(Configuration)\
obj\$(Configuration)\
$(WixExtDir)\WixUtilExtension.dll
WixUtilExtension
$(WixExtDir)\WixUIExtension.dll
WixUIExtension
$(WixExtDir)\WixIIsExtension.dll
WixIIsExtension
BasePath=..\..\BlazorAppForInstaller\BlazorAppForInstaller\Server\bin\Release\net6.0\publish;
```
После того, как вы внесете указанные изменения в файл *.wixproj* сохраните изменения и постройте проект. В результате, в корневой папке проекта инсталлятора должен появиться файл *ComponentsGenerated.wxs.*
В моем случае ComponentGenerated.wxs имеет следующее содержание
```
xml version="1.0" encoding="utf-8"?
```
Добавьте этот новый файл в проект инсталлятора (*Solution Explorer -> Add -> Existing Item*).
Product.wxs
-----------
Теперь, перейдем в файл **Product.wxs.** Если кратко, то это основной файл, в котором описывается вся логика создания инсталлятора, его конфигурация и метаданные. Для небольших решений проект wix может в полне себе состоять только из этого файла.
Давайте добавим компоненты в сам инсталлятор. Для этого нам необходимо перед закрывающимся тегом удалить узел (он генерится Wix по-умолчанию при создании проекта) на следующую секцию:
```
```
Таким образом, мы создали группу компонентов *ProductComponents*, которые будут развернуты по пути соответствующему свойству *INSTALLFOLDER* (она же виртуальная директория), при этом сами компоненты мы передали по ссылке из группы *PublishedComponents*, сгенерированной c помощью Heat.exe.
Удалите тег (ищите внутри тега Product) - он используется в качестве заглушки и, если его не удалить, то вы обнаружите, что вместе с .msi-файлом генерится *.cab-файл*. Нам же необходимо поместить его внутрь файла .msi. Для этого перед закрывающимся тегом необходимо добавить тег :
```
```
Тем самым мы описываем компонент *media.cab* – архив с файлами для установки. `EmbedCab=”yes”` – указывает на то, что архив будет встроен в .*msi-файл*, а свойство `DiskPrompt="CD-ROM #1"` – является легаси-наследием со времен, когда программные продукты распространялись на материальных носителях и разработчикам инсталляционных пакетов приходилось решать проблему поставки продукта на нескольких дисках из-за нехватки дискового пространства на носителях. Также не забываем добавить *Property* со ссылкой на *DiskPromt*, чтобы Windows Installer мог создать сообщение пользователю о необходимости вставить определенный диск. Обращаю внимание, что DiskPrompt является необязательным, и, если вы не планируете поставлять ваш продукт на физическом носителе, то и проставлять его ненужно (то же самое касается и Property Id="DiskPromt").
Теперь нам необходимо добавить *интерфейс* для взаимодействия с пользователем: сделать это можно двумя путями. Или самостоятельно описывать интерфейс, или воспользоваться готовыми шаблонами, которые поставляются вместе с wix. Так как разработка интерфейса – это очень объемная тема, мы воспользуемся *готовым решением*.
Щелкаем правой клавишей по названию проекта в Solution Explorer -> Add Reference — открываем папку, в которую был установлен WiX, подкаталог bin, файл WixUIExtension.dll.
Снова перед закрывающимся тегом добавляем следующий код:
```
```
Wix предлагает пользователю несколько сценариев пользовательского интерфейса один из которых называется *WixUI\_InstallDir* и, как можно догадаться из названия, позволяет пользователю выбирать в какую директорию будет произведена установка продукта. Путь до выбранной директории передается через свойство *INSTALLFOLDER*, которое используется в шаблоне *WixUI\_InstallDir* на что и указывается `Id="WIXUI_INSTALLDIR"`.
Работа с IIS
------------
Для установки проекта, в нашем случае, описанных шагов недостаточно – не случайно же был выбран web-проект: теперь его нужно затащить на *IIS*. Разработчики Wix позаботились о нас и добавили в пакет поставки *WixIISExtention* – расширение, позволяющее развернуть приложение на web-сервере.
Подключаем расширение WixIISExtention: правая кнопка маши по проекту -> Add Reference — директория в которую установлен WiX, подкаталог bin, файл *WixIISExtension.dll*. У меня здесь *C:\Program Files (x86)\WiX Toolset v3.11\bin\WixIISExtension.dll*
Снова правая кнопка мыши по проекту инсталлятора -> New item… -> Wix/v3 и выбираем *Installer File (.wxs)*. Назовем его *IISConfiguration.wxs*. Стираем все, что находится внутри файла и заменяем на следующее содержание:
```
xml version="1.0" encoding="UTF-8"?
```
Давайте разберем по тегам содержимое файла:
* внутри тега Wix добавляем ссылку на *IISExtention* c помощью вот этого атрибута `xmlns:iis="http://schemas.microsoft.com/wix/IIsExtension"`. Не забываем это делать, иначе проект не заведется.
* внутри тега *Fragment* начинаем описывать настройку *IIS*. Так как все компоненты должны получить путь установки обязательно упаковываем их в тег `Directory` или `DirectoryRef`, если директория уже объявлена. В нашем случае это `TARGETDIR` – корень виртуального каталога, объявленный на стадии создании проекта Wix
* объявляем компонент с помощью тега `Component`, присваиваем ему `ID` – не забывайте, что *Id* должен быть уникальным для каждого компонента (помним, что для базы данных *Windows Installer* он выполняет роль *первичного ключа*). Генерим *GUID* любым удобным для вас способом. Я предпочитаю использовать средства Visual Studio (*Tools -> Create GUID и выбрать Registry Format*). Указываем компоненту свойство `keypath=”yes”` – это необходимо, чтобы установщик удостоверился, что данный компонент не был ранее установлен чтобы избежать перетирания существующих версий компонента (будет заменен только в том случае, если будет предложена более новая версия компонента), а также для осуществления восстановления.
* Внутри компонента описываем настройки `AppPool` для `IIS`: прописываем уникальный *Id*, имя пула, указываем тип учетной записи – в нашем случае это *LocalSystem* (желающие получить дополнительную информацию о них могу перейти по ссылке <https://windowsnotes.ru/iis/application-pool-identities-v-iis/>). Указываем режим конвейера *Integrated* и последнюю доступную версию *.net clr*.
После того, как нами были описаны настройки WebPool’а мы должны сконфигурировать сайт, для чего снова создается новый компонент. Назовем его «InstallWebsite»:
* Конфигурация сайта производится с использованием свойств тега . Через свойства тега передаем его *Id* (помним, что он должен быть уникальным), описание и виртуальную директорию. Чтобы после установки получить сразу работающий проект, не требующий от пользователя дополнительных телодвижений добавим свойствам `AutoStart` и `StartOnInstall` значение *yes*.
* С помощью свойств тега `iis:WebAddress` передадим адрес сайта: в нашем случае он запустится локально на порту *8085* (можете выбрать любой доступный порт)
* В теге `iis:WebApplication` мы указали связь сайта с WebPool’ом
На этом IIS можно считать сконфигурированным. Теперь создаем группу компонентов с названием *BlazorAppIisConfiguration* (см. 35-ю строчку) и закидываем в нее два наших созданных выше компонента (с описанием конфигурации AppPool’а и сайта).
И снова Product.wxs
-------------------
Снова открываем файл *Product.wxs*. Добавляем *перед* закрывающимся тегом тег со следующим содержимым:
```
```
Первые два свойства традиционно `Id` и *Название*. Что касается свойства `Level` – оно служит для *включения* (при значении *«1»*) или *исключения* (при значении *«0»*) фичи из процесса установки. Делается это, как правило, путем добавления публичного свойства (тег `Property`), которое может принимать значение через аргументы командной строки или иными способами и последующим использованием через тег `Condition`, который должен располагаться внутри тега . Обязательно разберем работу с условиями, но не в этой статье.
Свойство `ConfigurableDirectory` указывает на название виртуальной директории в которой будет лежать наш программный продукт, нуждающийся в разворачивании на *IIS*. Свойства `AllowAdvertise="no"` и `Absent='disallow`' используем с указанными значениями, так как мы не планируем предоставлять пользователю возможность кастомизации процесса установки в части управления параметрами настройки IIS и записи файлов проекта.
Далее, внутрь указанного тега кладем ссылки на описанные ранее группы объектов (см. 7 и 8 строчки).
Теперь нам необходимо установить связь виртуальной директории, являющейся корневой для нашего проекта, с адресом в дисковом пространстве компьютера пользователя куда будет непосредственно установлен проект. Делается это следующим образом:
```
```
При создании проекта Wix внутри файла *Product.wxs* сразу после тега у вас уже будет шаблон, обозначенный тегами - замените его на код указанный выше. По сути, несмотря на то, что теги являются вложенными и *кажется*, что при установке будет создана иерархическая структура, фактически *все файлы будут установлены в папку, которая будет выбрана пользователем во время установки*, т.к. property `WIXUI_INSTALDIR` (как было описано выше, с помощью этого свойства шаблону UI передается виртуальный путь) содержит ссылку на виртуальную директорию `INSTALLFODER`, которая является *корнем* для нашего проекта.
Что касается тега `Fragment`, то с помощью него достигается *структурирование* проекта. Раздел, помещенный внутрь тега `Fragment`, может быть перемещен *в отдельный файл* или расположен практически *в любом месте файла*. Иначе, пришлось бы все инструкции для создания инсталлятора помещать внутрь тега `Product`.
Конечный вариант файла Product.wxs
```
xml version="1.0" encoding="UTF-8"?
```
Внимательный читатель заметит, что в конечном варианте отсутствует следующий кусок, который был описан вначале:
```
```
Для лаконичности .xml-описания в нашем случае можно отказаться от создания еще одной группы компонентов внутри файла *Product.wxs* и добавить ссылку на существующую группу в `Feature`- см. 26 строку файла *Product.wxs*.
После того, как все необходимые .xml документы будут созданы, давайте соберем проект: *правая кнопка мыши по проекту wix -> build*. После сборки из папки проекта перейдем по следующему пути: *~\InstallerForBlazorApp\bin\Release* (или *Debug* - в зависимости от выбранной вами конфигурации сборки проекта в Visual Studio) – в нем лежит собранный инсталлятор *InstallerForBlazorApp.msi*. Запускаем его:
Принимаем лицензию (так как мы не передавали файл лицензии, то имеем Lorem impsum…)
Далее мы имеем возможность *выбрать директорию*, в которую будет произведена установка продукта (по умолчанию, *Program Files (x86)*)
*Next, next, install.*
После положительного ответа на запрос разрешения на установку, продукт будет развернут в указанной директории.
Убедиться в этом вы можете сами, перейдя в директорию установки. Однако, это еще не говорит о том, что все прошло по плану. *Откройте IIS -> Application Pool*. Там должен появится созданный нами новый пул приложений
А в папке сайтов появится новый *BlazorAppWasm*
Нажимаем на Browse: <http://127.0.0.1:8085>/ и в браузере открывается страница установленного проекта, после чего установку можно считать успешной.
*Удалить* приложение вы можете или через установку и удаление программ, или непосредственно через инсталлятор путем его повторного запуска. При этом, будет произведено *не только удаление файлов,* *но и пула с сайтом из IIS*.
Таким образом, можно резюмировать, что технология Wix позволяет *относительно* быстро описать и собрать инсталлятор (который позволяет произвести выбор директории установки) для достаточно большого проекта – главное *знать* какие теги и в каком *порядке* использовать.
При наличии у хабрчан интереса к данной теме, я планирую подробно рассказать про работу с реестрами, создание пользовательских действий, разработку интерфейса, внедрение скриптов в процесс установки, написание бутстрапера, а также использование расширений и инструментов, поставляемых вместе с Wix. | https://habr.com/ru/post/668082/ | null | ru | null |
# Hilt+Retrofit+Coroutine
В данной статье хочется показать подробный пример использования Hilt совместно с Retrofit, запросы к бд будут ассинхронно выполнять с помощью Coroutines.
* Hilt - это библиотека для внедрения зависимостей для Android, которая сокращает количество шаблонов для ручного внедрения зависимостей в ваш проект. <https://developer.android.com/training/dependency-injection/hilt-android>
* Retrofit - типобезопасный HTTP-клиент для Android и Java. Позволяет нам не особо напрягясь делать GET, POST, PUT и другие запросы.
* Coroutines - шаблон проектирования параллелизма, который можно использовать в Android для упрощения кода, который выполняется асинхронно.
Подключение зависимостей
------------------------
В top-level build file, то есть build.gradle который находиться в самой папке нашего проекта, а не в app, добавляем следующее:
```
buildscript {
...
ext.hilt_version = '2.35'
dependencies {
...
classpath "com.google.dagger:hilt-android-gradle-plugin:$hilt_version"
}
}
```
Далее, уже в build.gradle, который находится в папочке app, Navigation подключаем для удобства ориентации <https://developer.android.com/guide/navigation/navigation-getting-started>:
```
plugins {
id("kotlin-kapt")
id("dagger.hilt.android.plugin")
}
android {
...
}
dependencies {
//Hilt
implementation("com.google.dagger:hilt-android:$hilt_version")
kapt("com.google.dagger:hilt-android-compiler:$hilt_version")
//Retrofit
implementation 'com.squareup.retrofit2:retrofit:2.9.0'
implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
implementation 'androidx.lifecycle:lifecycle-livedata-ktx:2.2.0'
//Navigation
implementation("androidx.navigation:navigation-fragment-ktx:2.3.5")
implementation("androidx.navigation:navigation-ui-ktx:2.3.5")
}
```
Теперь расставим аннотации
--------------------------
В соответствии с документацией : "Все приложения, использующие Hilt, должны содержать класс Application, помеченный @HiltAndroidApp ".
Поэтому создаём класс MyApplication, который наследуем от Application:
```
@HiltAndroidApp
class MyApplication : Application() {
}
```
Также не забываем включить этот класс в AndroidManifest, чтобы при сборке всего приложения использовался именно наш класс:
```
android:name=".MyApplication"
```
Теперь добавляем аннотацию @AndroidEntryPoint к MainFragment и MainActivity. Эта аннотацию говорит Hilt, чтобы он генерировал классы Component <https://developer.android.com/training/dependency-injection/hilt-android#generated-components> . Каждый компонент отвечает за зависимости своего класса, ActivityComponent за Activity, FragmentComponent за Fragment. Именно эта аннотация позволяет нам в дальнейшеи привязывать зависимости к Fragment, Activity и т.д.. Также если вы указали эту аннотацию, например, у какого-то фрагмента, её также необходимо указать у Activity, к которой он привязан. [Дополнительно про иерархию можно посмотреть по ссылке](https://developer.android.com/training/dependency-injection/hilt-android#component-hierarchy).
```
@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
}
}
```
```
@AndroidEntryPoint
class MainFragment : Fragment() {
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
// Inflate the layout for this fragment
return inflater.inflate(R.layout.fragment_main, container, false)
}
}
```
Далее, в соответствии с [архитектурой MVVM](https://medium.com/nuances-of-programming/mvvm-%D0%BD%D0%B0-android-%D1%81-%D0%BA%D0%BE%D0%BC%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%82%D0%B0%D0%BC%D0%B8-%D0%B0%D1%80%D1%85%D0%B8%D1%82%D0%B5%D0%BA%D1%82%D1%83%D1%80%D1%8B-%D0%B1%D0%B8%D0%B1%D0%BB%D0%B8%D0%BE%D1%82%D0%B5%D0%BA%D0%B0-koin-e2e77b77950e) нам нужно создать ViewModel, которая будет содержать наши LiveData, данные в которые мы будем загружать из MainRepository:
```
@Singleton
class MainRepository @Inject constructor() {
...
}
```
Аннотация @Singleton говорит Hilt, что наш MainRepository будет привязан к SIngletonComponent, то есть к Application. Первый раз, когда где-то будет создаваться MainRepository, он создаст сам экземпляр класса, в последующие разы будет доставаться тот же самый, созданный в 1 раз MainRepository. Но чтобы Hilt знал, как создавать репозиторий, нужно использовать вот такой синтаксис : @Inject constructor(....). Если мы далее захотим где-то в коде получить MainRepository, то сделать это можно так: @Inject lateinit var repository: MainRepository.
Теперь объявим ViewModel:
```
@HiltViewModel
class MainViewModel @Inject constructor(val repository: MainRepository) : ViewModel(){
...
}
```
В Hilt для ViewModel есть специальная аннотация @HiltViewModel , ViewModel также как и раньше будут привязаны к жизненным циклам Fragment или Activity, смотря где вы захотите её создать. Также необходимо указать @Inject, по причинам описанным выше, а тк Hilt уже знает, как создавать repository, всё будет отлично работать(при указании @Inject , Hilt должен знать, как создавать объекты, которые находятся в constructor). Теперь во фрагменте мы можем следующим образом получить нашу ViewModel:
```
private val viewModel by viewModels()
```
Возникает резонный вопрос, зачем все эти заморочки с Hilt, если мы и до этого могли получить ViewModel с помощью by viewModels. Всё дело в том, что так можно сделать, если у нашей ViewModel пустой конструктор, что в случае с MainViewModel не так. Поэтому пришлось бы написать гораздо больше шаблонного кода, использование которого мы и хотим избежать.
Retrofit
--------
При использовании Retrofit также необходимо разрешение на использование интернета, для получения данных удалённой базы данных(в данном примере используется Firebase), поэтому перед тегом Cоздадим data class, в котором будут храниться данные о пользователе:
```
data class User(
val age : Int,
val name : String
)
```
Теперь создаём interface, нужный для использования Retrofit, где пропишем все нужные нам запросы:
```
interface MainService {
@GET("User/{userId}.json")
suspend fun getUser(@Path("userId") userId : Int) : Response
}
```
Пока у нас 1 запрос GET. Аннотация @Path означает, что значение userId будет подставляться в сегмент URL {userId}.
```
class MainRemoteData @Inject constructor(private val mainService : MainService) {
suspend fun getUser(userId : Int) = mainService.getUser(userId)
}
```
В дальнейшем тут можно добавить логику обработки ответа: кода ответа, сообщения об ошибке и т.д..
Далее, поскольку у интерфейса нет конструктора, а значит Hilt не может знать как его реализовать. Также Retrofit сторонняя библиотеке, значит о ней Hilt тоже ничего не знает, как же тогда поступить, чтобы Hilt знал как предоставлять экземпляры того или иного класса? На помощь нам придёт Module, он представляет собой набор методов, которые указывают как создать экземпляр нужного нам класса:
```
@Module
@InstallIn(SingletonComponent::class)
object AppModule {
@Provides
fun providesBaseUrl() : String = "https://example-hilt-retrofit-default-rtdb.firebaseio.com/"
@Provides
@Singleton
fun provideRetrofit(BASE_URL : String) : Retrofit = Retrofit.Builder()
.addConverterFactory(GsonConverterFactory.create())
.baseUrl(BASE_URL)
.build()
@Provides
@Singleton
fun provideMainService(retrofit : Retrofit) : MainService = retrofit.create(MainService::class.java)
@Provides
@Singleton
fun provideMainRemoteData(mainService : MainService) : MainRemoteData = MainRemoteData(mainService)
}
```
Аннотация @InstallIn говорит в контексте чего будут доступны наши зависимости. В данном случае мы хотим получать их в любом месте приложения и поэтому указываем SingletonComponent. Далее мы указываем аннотацию @Provides, чтобы Hilt знал как предоставлять экземпляры типов Retrofit и т.д.. Аннотация @Singleton , как было сказано ранее, говорит Hilt, чтобы он не пересоздавал каждый раз новый экземпляр, а предоставлял уже имеющийся(если ни разу ещё не был создан, то он его создаст).
Заметим, что мы также говорим, как предоставлять экземпляр String, это значит, что если мы где-то создадим класс по типу такого:
```
@Singleton
class Test @Inject constructor(private val str : String) {
fun print() {
println(str)
}
}
```
То при его получении с помощью:
```
@Inject lateinit var test : Test
```
И вызове метода print(), будет печататься именно BASE\_URL.
Передаём данные во ViewModel
----------------------------
Теперь по сути основная работа выполнена, осталось поместить наши данные во ViewModel, а потом из фрагмента достать LiveData и следить за изменением данных в ней.
Прокидываем данные через репозиторий:
```
@Singleton
class MainRepository @Inject constructor(
private val remoteData : MainRemoteData
) {
suspend fun getUser(userId : Int) = remoteData.getUser(userId)
}
```
Потом превращаем их в LiveData во ViewModel:
```
@HiltViewModel
class MainViewModel @Inject constructor(val repository: MainRepository) : ViewModel(){
fun getUser(userId : Int) : LiveData {
return liveData {
val data = repository.getUser(userId)
data.body()?.let { emit(it) }
}
}
}
```
Вызов emit () приостанавливает выполнение блока до тех пор, пока значение LiveData не будет установлено в основном потоке. То есть пока наша suspend fun не выполниться.
UI
--
Теперь наконец отобразим данные, которые мы получаем из Firebase. Для этого в MainFragment добавим 2 Textview:
```
xml version="1.0" encoding="utf-8"?
```
И в MainFragment будем устанавливать значения, которые мы получили из ViewModel:
```
@AndroidEntryPoint
class MainFragment : Fragment() {
private val viewModel by viewModels()
@SuppressLint("SetTextI18n")
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View {
val constraintLayout = inflater.inflate(R.layout.fragment\_main, container, false)
as ConstraintLayout
val name : TextView = constraintLayout.findViewById(R.id.name\_field)
val age : TextView = constraintLayout.findViewById(R.id.age\_field)
viewModel.getUser(0).observe(viewLifecycleOwner, {user ->
name.text = "name : " + user.name
age.text = "age : " + user.age.toString()
})
return constraintLayout
}
}
```
Результат(конечно не очень красивый, но мы к этому и не стремились):
Вот и всё, простой пример использования Hilt+retrofit готов! [Полный код доступен по ссылке](https://github.com/DbnStr/Retrofit-Hilt_Example). | https://habr.com/ru/post/568792/ | null | ru | null |
# Приложение для конвертирования jpg файлов в pdf файл
Здравствуйте, читатели моего блога. Сегодня я расскажу про программы, которые помогут при конвертации большого числа рисунков или фотографий формата jpg или bmp в файл pdf.
Данный способ очень хорош тем, что сохраняет качество изображений и позволяет конвертировать и упаковывать огромное количество файлов.
Аналогичных программ в интернете не так много и, в основном, они платные.
Разработать такой способ вынудило меня острая необходимость. Так как мне часто приходится работать с большим количеством файлов, которые необходимо структурировать с сохранением качества.
А те программы, которые бесплатные имеют ряд ограничений по количеству конвертируемых файлов и по качеству конвертации.
Представленные программы очень полезны для людей, занимающихся написанием книг, составлением огромных презентаций и вёрсткой литературы и другой бумажной продукции.
Программы написаны на языке python
Всего программ две.
Первая программа конвертирует файлы jpg в файлы формата pdf. Все сконвертированные файлы собираются в отдельную папку. Качество файлов не изменяется.
Здесь нам понадобиться модуль os и PIL
```
import os
import PIL.Image
def img2pdf(fname):
filename = fname
name = filename.split('.')[0]
im = PIL.Image.open(filename)
if not os.path.exists('im2pdf_output'):
os.makedirs('im2pdf_output')
newfilename = ''.join(['im2pdf_output/',name,'.pdf'])
PIL.Image.Image.save(im, newfilename, "PDF", resolution = 100.0)
print("processed successfully: {}".format(newfilename))
files = [f for f in os.listdir('./') if f.endswith('.jpg')]
for fname in files:
img2pdf(fname)
```
Полученные файлы формата pdf можно собрать в один файл pdf и тем самым сформировать книгу, журнал, презентацию и т.д..
Для этого нам понадобится модуль PyPDF2
```
from PyPDF2 import PdfFileMerger
pdfs = []
t=1
for i in range(8):
f=str(t)+".pdf"
pdfs.append(f)
t=t+1
print(pdfs)
merger = PdfFileMerger()
for pdf in pdfs:
merger.append(pdf)
merger.write("result.pdf")
merger.close()
```
Подробное видео о данных программах представлено ниже.
Здесь представлена ссылка на скачивание файлов
[СКАЧАТЬ](https://yadi.sk/d/iZV4uhE9_MG9wA) | https://habr.com/ru/post/536926/ | null | ru | null |
# Разработка REST-серверов на Go. Часть 2: применение маршрутизатора gorilla/mux
Перед вами второй материал из серии статей, посвящённой разработке REST-серверов на Go. В [первом](https://habr.com/ru/company/ruvds/blog/559816/) материале этой серии мы создали простой сервер, пользуясь стандартными средствами Go, а после этого отрефакторили код формирования JSON-данных, вынеся его во вспомогательную функцию. Это позволило нам выйти на достаточно компактный код обработчиков маршрутов.
**Предыдущие части:**
[Разработка REST-серверов на Go. Часть 1: стандартная библиотека](https://habr.com/ru/company/ruvds/blog/559816/)
[**Вы тут** — Разработка REST-серверов на Go. Часть 2: применение маршрутизатора gorilla/mux](https://habr.com/ru/company/ruvds/blog/561108/)
[Разработка REST-серверов на Go. Часть 3: использование веб-фреймворка Gin](https://habr.com/ru/company/ruvds/blog/562878/)
[Разработка REST-серверов на Go. Часть 4: применение OpenAPI и Swagger](https://habr.com/ru/company/ruvds/blog/564508/)
[Разработка REST-серверов на Go. Часть 5: Middleware](https://habr.com/ru/company/ruvds/blog/566198/)
[Разработка REST-серверов на Go. Часть 6: аутентификация](https://habr.com/ru/company/ruvds/blog/567280/)
Там мы говорили об одной проблеме нашего сервера, которая заключается в том, что логика маршрутизации разбросана по нескольким местам нашей программы.
[](https://habr.com/ru/company/ruvds/blog/560742/)
Это — проблема, с которой сталкиваются все, кто пишет HTTP-сервера, не используя зависимости. Если только сервер, принимая во внимание систему его маршрутов, не является до крайности минималистичной конструкцией (например — это некоторые специализированные серверы, имеющие лишь один-два маршрута), то оказывается, что размеры и сложность организации кода маршрутизатора — это нечто такое, на что очень быстро обращают внимание опытные программисты.
▍ Улучшенная система маршрутизации
----------------------------------
Первой мыслью, которая может прийти в голову того, кто решил улучшить наш сервер, может стать идея об абстрагировании системы его маршрутизации, возможно — с использованием набора функций или типа данных с методами. Есть много интересных подходов к решению этой задачи, применимых в каждой конкретной ситуации. В экосистеме Go существует множество мощных и успешно используемых в различных проектах библиотек сторонних разработчиков, реализующих возможности маршрутизатора. Я настоятельно рекомендую взглянуть на [этот](https://benhoyt.com/writings/go-routing/) материал, где сравниваются несколько подходов к обработке простых наборов маршрутов.
Перед переходом к практическому примеру вспомним о том, как устроен API нашего сервера:
```
POST /task/ : создаёт задачу и возвращает её ID
GET /task/ : возвращает одну задачу по её ID
GET /task/ : возвращает все задачи
DELETE /task/ : удаляет задачу по ID
GET /tag/ : возвращает список задач с заданным тегом
GET /due/// : возвращает список задач, запланированных на указанную дату
```
Для того чтобы сделать систему маршрутизации удобнее, мы можем поступить так:
1. Можно создать механизм, позволяющий задавать отдельные обработчики для разных методов одного и того же маршрута. Например — запрос `POST /task/` должен обрабатываться одним обработчиком, а запрос `GET /task/` — другим.
2. Можно сделать так, чтобы обработчик маршрута выбирался бы на основе более глубокого, чем сейчас, анализа запросов. То есть, например, у нас при таком подходе должна быть возможность указать, что один обработчик обрабатывает запрос к `/task/`, а другой обработчик обрабатывает запрос к `/task/` с числовым `ID`.
3. При этом система обработки маршрутов должна просто извлекать числовой `ID` из `/task/` и передавать его обработчику каким-нибудь удобным для нас способом.
Написание собственного маршрутизатора на Go — это очень просто. Это так из-за того, что организовывать работу с HTTP-обработчиками можно, используя компоновку. Но тут я не стану потакать своему желанию написать всё самому. Вместо этого предлагаю поговорить о том, как организовать систему маршрутизации с использованием одного из самых популярных маршрутизаторов, который называется [gorilla/mux](https://github.com/gorilla/mux).
▍ Сервер приложения для управления задачами, использующий gorilla/mux
---------------------------------------------------------------------
Пакет gorilla/mux представляет собой один из самых старых и самых популярных HTTP-маршрутизаторов для Go. Слово «mux», в соответствии с [документацией](https://pkg.go.dev/github.com/gorilla/mux) к пакету, расшифровывается как «HTTP request multiplexer» («Мультиплексор HTTP-запросов») (такое же значение «mux» имеет и в стандартной библиотеке).
Так как это — пакет, нацеленный на решение единственной узкоспециализированной задачи, пользоваться им очень просто. Вариант нашего сервера, в котором для маршрутизации используется gorilla/mux, можно найти [здесь](https://github.com/eliben/code-for-blog/tree/master/2021/go-rest-servers/gorilla). Вот код определения маршрутов:
```
router := mux.NewRouter()
router.StrictSlash(true)
server := NewTaskServer()
router.HandleFunc("/task/", server.createTaskHandler).Methods("POST")
router.HandleFunc("/task/", server.getAllTasksHandler).Methods("GET")
router.HandleFunc("/task/", server.deleteAllTasksHandler).Methods("DELETE")
router.HandleFunc("/task/{id:[0-9]+}/", server.getTaskHandler).Methods("GET")
router.HandleFunc("/task/{id:[0-9]+}/", server.deleteTaskHandler).Methods("DELETE")
router.HandleFunc("/tag/{tag}/", server.tagHandler).Methods("GET")
router.HandleFunc("/due/{year:[0-9]+}/{month:[0-9]+}/{day:[0-9]+}/", server.dueHandler).Methods("GET")
```
Обратите внимание на то, что одни только эти определения тут же закрывают первые два пункта вышеприведённого списка задач, которые надо решить для повышения удобства работы с маршрутами. Благодаря тому, что в описании маршрутов используются вызовы `Methods`, мы можем с лёгкостью назначать в одном маршруте разные методы для разных обработчиков. Поиск совпадений с шаблонами (с использованием регулярных выражений) в путях позволяет нам легко различать `/task/` и `/task/` на самом верхнем уровне описания маршрутов.
Для того чтобы разобраться с задачей, которая имеется в третьем пункте нашего списка, посмотрим на использование `getTaskHandler`:
```
func (ts *taskServer) getTaskHandler(w http.ResponseWriter, req *http.Request) {
log.Printf("handling get task at %s\n", req.URL.Path)
// Тут и в других местах мы не проверяем ошибку Atoi, так как маршрутизатор
// принимает лишь данные, проверенные регулярным выражением [0-9]+.
id, _ := strconv.Atoi(mux.Vars(req)["id"])
ts.Lock()
task, err := ts.store.GetTask(id)
ts.Unlock()
if err != nil {
http.Error(w, err.Error(), http.StatusNotFound)
return
}
renderJSON(w, task)
}
```
В определении маршрутов маршрут `/task/{id:[0-9]+}/` описывает регулярное выражение, используемое для разбора пути и назначает идентификатор «переменной» `id`. К этой «переменной» можно обратиться, вызвав функцию `mux.Vars` с передачей ей `req` (эту переменную gorilla/mux хранит в контексте каждого запроса, а `mux.Vars` представляет собой удобную вспомогательную функцию для работы с ней).
▍ Сравнение различных подходов к организации маршрутизации
----------------------------------------------------------
Вот как выглядит последовательность чтения кода, применяемая в исходном варианте сервера тем, кто хочет разобраться в том, как обрабатывается маршрут `GET /task/`.
А вот что нужно прочитать тому, кто хочет понять код, в котором применяется gorilla/mux:
При использовании gorilla/mux придётся не только меньше «прыгать» по тексту программы. Тут, кроме того, читать придётся гораздо меньший объём кода. По моему скромному мнению это очень хорошо с точки зрения улучшения читабельности кода. Описание путей при использовании gorilla/mux — это простая задача, при решении которой нужно написать лишь небольшой объём кода. И тому, кто читает этот код, сразу понятно то, как этот код работает. Ещё одно преимущество такого подхода заключается в том, что все маршруты можно увидеть буквально раз взглянув на код, расположенный в одном месте. И, на самом деле, код настройки маршрутов выглядит теперь очень похожим на описание нашего REST API, выполненное в произвольной форме.
Мне нравится пользоваться такими пакетами, как gorilla/mux, из-за того, что подобные пакеты представляют собой узкоспециализированные инструменты. Они решают одну единственную задачу и решают её хорошо. Они не «забираются» в каждый уголок программного кода проекта, а значит, их, при необходимости можно легко убрать или заменить чем-то другим. Если вы посмотрите [полный код](https://github.com/eliben/code-for-blog/tree/master/2021/go-rest-servers/gorilla) того варианта сервера, о котором мы говорим в этой статье, то сможете увидеть, что область использования механизмов gorilla/mux ограничена несколькими строками кода. Если, по мере развития проекта, в пакете gorilla/mux будет обнаружено какое-то ограничение, несовместимое с особенностями этого проекта, задача замены gorilla/mux на другой маршрутизатор стороннего разработчика (или на собственный маршрутизатор) должна решаться достаточно быстро и просто.
Какой маршрутизатор вы использовали бы при разработке REST-сервера на Go?
**Переведенные статьи из этой серии:**
[Разработка REST-серверов на Go. Часть 1: стандартная библиотека](https://habr.com/ru/company/ruvds/blog/559816/)
[**Вы тут** — Разработка REST-серверов на Go. Часть 2: применение маршрутизатора gorilla/mux](https://habr.com/ru/company/ruvds/blog/561108/)
[Разработка REST-серверов на Go. Часть 3: использование веб-фреймворка Gin](https://habr.com/ru/company/ruvds/blog/562878/)
[Разработка REST-серверов на Go. Часть 4: применение OpenAPI и Swagger](https://habr.com/ru/company/ruvds/blog/564508/)
[Разработка REST-серверов на Go. Часть 5: Middleware](https://habr.com/ru/company/ruvds/blog/566198/)
[Разработка REST-серверов на Go. Часть 6: аутентификация](https://habr.com/ru/company/ruvds/blog/567280/)
[](https://ruvds.com/news/read/142?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=razrabotka_rest-serverov_na_go._chast_2:_primenenie_marshrutizatora_gorilla/mux)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=razrabotka_rest-serverov_na_go._chast_2:_primenenie_marshrutizatora_gorilla/mux) | https://habr.com/ru/post/561108/ | null | ru | null |
# Цикличность и временное отключение приемников событий в SharePoint
Как Вы можете знать, в SharePoint существует множество приемников событий (EventReceiver), которые позволяют вызывать пользовательский код при выполнении стандартных операций с объектами SharePoint, например добавление/удаление/изменение элементов списков. Работа с приемниками событий заслуживает отдельной статьи, но их по данной тематике и так довольно много, например [тут](http://msdn.microsoft.com/ru-ru/library/gg749858(v=office.14).aspx).
Сегодня мы рассмотрим 2 частных случая проблем, которые могут возникнуть у начинающего разработчика SharePoint при работе с ресиверами:
**1. Цикличный вызов событий.**
Довольно легко можно представить ситуацию, когда ресивер может “загнать” себя в бесконечный цикл. Для примера возьмем приемник событий для элемента списка “После обновления” (ItemUpdated). Ваш код выполняет дополнительные действия с данным элементом (например, на основе введенных пользователем данных, производите дополнительные вычисления и записываете их в требуемое поле), после чего, конечно же, вызываете Update для сохранения данных. После вызова что должно произойти? Конечно. Снова вызовется Ваш код, который был описан в ресивере. И так бесконечно.
```
public override void ItemUpdated(SPItemEventProperties properties)
{
base.ItemUpdated(properties);
SPListItem Item = properties.ListItem;
Item["Title"] = DateTime.Today.ToString("dd.MM.yyyy");
Item.Update();
}
```
По непонятным мне причинам, часть разработчиков считает, что для отключения выполнения обработчиков событий достаточно вызывать **SystemUpdate** вместо **Update** у объекта. Но это не так. Мало того, что на [msdn](http://msdn.microsoft.com/en-us/library/microsoft.sharepoint.splistitem.systemupdate(v=office.15).aspx) говорится о том, что данный метод позволяет обновлять элементы списка без обновления полей Изменено (Modified), Кем изменено(ModifiedBy) и увеличению версии элемента, так и простым экспериментальным путем доказывается обратное.
То есть использование **SystemUpdate** для отключения вызова обработчиков событий будет не достаточно, хотя, признаюсь, в вышеуказанном примере как раз таки лучше вызывать **SystemUpdate** вместо **Update**, чтобы исключить изменения вышеуказанных полей и созданию новой версии элемента, если включена версионность.
Данную проблему поможет нам решить свойство **EventFiringEnabled** у **SPEventReceiverBase** (или даже у текущего наследуемого объекта от **SPEventReceiverBase**).
Данное свойство позволяет управлять возможностью вызова каких-либо обработчиков событий унаследованных от класса **SPEventReceiverBase** в текущем потоке. То есть в Вашем коде Вы можете выключать и включать вызовы обработчиков событий и не бояться, что другой код или простая работа пользователя (которая также вызывает ресиверы) будет омрачена отключением или выключением обработчиков в Вашем конкретном методе.
```
public override void ItemUpdated(SPItemEventProperties properties)
{
base.ItemUpdated(properties);
SPListItem Item = properties.ListItem;
this.EventFiringEnabled = false;
Item["Title"] = DateTime.Today.ToString("dd.MM.yyyy");
Item.Update();
this.EventFiringEnabled = true;
}
```
При вызове указанного кода при выполнении метода вызов ресиверов будет отключен. Стоит обратить внимание на то, что все ресиверы, унаследованные от **SPEventReceiverBase**, при установке свойства **EventFiringEnabled** в **false** будут отключены и об этом необходимо будет позаботиться самим. То есть Если в промежутке кода между выключением вызова ресиверов и включением Вы попытаетесь обновить другой список, к которому привязан обработчик событий на обновление, он не выполнится (Почему? Об этом немного ниже). Код, который должен был быть выполненным, необходимо выполнить принудительно.
Если обратить внимание на указанный выше код, то станет сразу понятно, что он не оптимален. Как минимум логичнее обернуть его в try-catch-finally(ну или как минимум просто try-finally). Вы же знаете что [это](http://msdn.microsoft.com/ru-ru/library/dszsf989.aspx) или [это](http://msdn.microsoft.com/ru-ru/library/zwc8s4fz.aspx)?
В результате получится следующий код, который независимо от результата на выходе включит выполнение обработчиков событий обратно
```
public override void ItemUpdated(SPItemEventProperties properties)
{
base.ItemUpdated(properties);
try
{
SPListItem Item = properties.ListItem;
this.EventFiringEnabled = false;
Item["Title"] = DateTime.Today.ToString("dd.MM.yyyy");
Item.Update();
}
finally
{
this.EventFiringEnabled = true;
}
}
```
Ниже по тексту будет представлен еще один возможный вариант отключения с инструкцией *using*
**2. Необходимость отключения событий при выполнении определенных операций вне ресивера.**
Как отключить выполнение ресиверов внутри самого ресивера мы разобрались. Но очень часть появляется необходимость отключить выполнение ресиверов вне самого ресивера. То есть Вы, например, в консольном приложении хотите обновить элемент списка, но не хотите чтобы вызывался ресивер, который обработает данные в нем и перезапишет его, произвести необходимые манипуляции с элементом и тогда уже обновить с ресивером.
По своей сути задача очень схожа с предыдущей, но у нас нет объекта **SPEventReceiverBase** и отключать вызов ресиверов нечему. Тут необходимо обратиться к рефлетору и посмотреть, что из себя представляет данный класс и как нам дальше быть.
```
protected bool EventFiringEnabled
{
get
{
return !SPEventManager.EventFiringDisabled;
}
set
{
SPEventManager.EventFiringDisabled = !value;
}
}
```
Из кода видно, что у класса есть свойство **EventFiringEnabled** (мы им чуть ранее пользовались для отключения вызова событий) и с его помощью получается или устанавливается значение из статического свойства **SPEventManager.EventFiringDisabled**. Код данного свойства представлен ниже:
```
internal static bool EventFiringDisabled
{
get
{
SPEventManager.EnsureTlsEventFiringDisabled();
object data = Thread.GetData(SPEventManager.m_tlsEventFiringDisabled);
return data != null && (bool) data;
}
set
{
SPEventManager.EnsureTlsEventFiringDisabled();
Thread.SetData(SPEventManager.m_tlsEventFiringDisabled, (object) (bool) (value ? 1 : 0));
}
}
```
Так как метод статический, а внутренняя работа основана уже на потоках, то получается, что каждый унаследованный от **SPEventReceiverBase** класс работает уже не совсем с контекстом текущего объекта. Требуемая информация читается и записывается в отведенные для наших потоков ячейках памяти. Получается, что не столько важно из какого ресивера выполняется отключение или включение вызовов других обработчиков, сколько важно в каком потоке это делается. Таким образом, достаточно создать собственный класс, унаследованный от **SPEventReceiverBase** (или от **SPItemEventReceiver** для нашего конкретного случая, который в свою очередь также является наследником ), в требуемом месте кода инициализировать экземпляр и работать с уже привычным нам свойством **EventFiringEnabled**.
```
public class DisableItemEvents : SPItemEventReceiver
{
public bool CustomEventFiringEnabled
{
get { return base.EventFiringEnabled; }
set { base.EventFiringEnabled = value; }
}
}
```
И вызывать, например, следующим образом:
```
var EventsDisable = new DisableItemEvents();
try
{
Item["Title"] = DateTime.Today.ToString("dd.MM.yyyy");
EventsDisable.CustomEventFiringEnabled = false;
Item.Update();
}
finally
{
EventsDisable.CustomEventFiringEnabled = true;
}
```
Получилось то, чего мы и ожидали. При обновлении не отработал ресивер. И как я сказал ранее, данный подход имеет право на жизнь и многие таким пользуются, но данную конструкцию я бы описал немного иначе. Мне очень нравятся using-паттерны. Как минимум за то, что используя данный функционал можно быть уверенным, что независимо от ошибок внутри инструкции, всегда будет вызван Dispose.
Свой класс я описал следующим образом:
```
public class DisableItemEvents : SPItemEventReceiver, IDisposable
{
private bool _EventStatus;
public DisableItemEvents()
{
_EventStatus = base.EventFiringEnabled;
base.EventFiringEnabled = false;
}
public void Dispose()
{
base.EventFiringEnabled = _EventStatus;
}
}
```
Работа с данным классом получается следующей:
```
using (new DisableItemEvents())
{
Item.Update(); // Вызов ресиверов НЕ происходит
}
Item.Update(); // Вызов ресиверов происходит
```
Здесь уже комментарии излишни, но тем не менее. При инициализации объекта **DisableItemEvents** будет сохранено первоначальное значение свойства **EventFiringEnabled** и установлено в false. А при диспоузе объекта свойство **EventFiringEnabled** будет возвращено обратно.
Таким образом мы рассмотрели возможные варианты отключения вызовов обработчиков событий как внутри ресиверов, так и из вне. | https://habr.com/ru/post/220177/ | null | ru | null |
# Бесшовная (почти) миграция между мажорными релизами PostgreSQL с помощью логической репликации
У нас в True Engineering на одном проекте назрела необходимость в смене версии PostgreSQL с 9.6 на 11.1.
Зачем? База данных на проекте уже объемом 1,5 Tb и растет. Перформанс – одно из основных требований к системе. А сама структура данных эволюционирует: добавляются новые колонки, меняются существующие. Новая версия Postgres научилась эффективно работать с добавлением новых колонок с дефолтным значением, так что не нужно городить кастомных костылей на уровне приложения. Ещё в новой версии добавили несколько новых способов партиционирования таблиц, что тоже крайне полезно в условиях большого объема данных.
Итак, решено, мигрируем. Конечно, можно поднять параллельно со старой новую версию сервера PostgreSQL, остановить приложение, через dump/restore (или pg\_upgrade) переместить базу и снова запустить приложение. Нам это решение не подошло из-за большого размера базы, к тому же, приложение работает в боевом режиме, и на даунтайм есть считанные минуты.
Поэтому мы решили попробовать миграцию с помощью логической репликации в PostgreSQL с использованием стороннего плагина под названием [pglogical](https://www.2ndquadrant.com/en/resources/pglogical/).
В процессе «проб» мы столкнулись с весьма обрывочной документацией по этому процессу (а на русском языке её вообще нет), а также некоторыми подводными камнями и неочевидными нюансами. В этой статье мы хотим изложить свой опыт в виде Tutorial.
**TL;DR**
* Всё получилось (не без костылей, о них и статья).
* Мигрировать можно в рамках PostgreSQL версии от 9.4 до 11.x, с любой версии на любую, вниз или вверх.
* Даунтайм равен времени, которое требуется вашему приложению, чтобы переподключиться к новому серверу БД (в нашем случае это был перезапуск всего приложения, но в дикой природе, очевидно, «возможны варианты»).
### Почему нам не подошло решение «в лоб»
Как мы уже сказали, самый простой выход: поднять параллельно со старой новую версию сервера PostgreSQL, остановить приложение, через dump/restore (или pg\_upgrade) переместить базу и снова запустить приложение. Для баз небольшого объёма, в принципе, это вполне подходящий вариант (или, в общем случае — объём неважен, когда у вас есть возможность даунтайма приложения на время «переливания» БД со старого сервера на новый, каким бы долгим это время ни было). Но в нашем случае база занимает порядка 1,5 Tb на диске, и её перемещение — это вопрос не минут, а нескольких часов. Приложение же, в свою очередь, работает в боевом режиме, и даунтайма дольше пары минут очень хотелось избежать.
Также против этого варианта играл ещё и тот факт, что мы используем Master-Slave репликацию и не можем безболезненно выключить Slave-сервер из рабочего процесса. А значит, для переключения приложения со старой версии PostgreSQL на новую после миграции Master-сервера требовалось бы готовить и новый Slave-сервер до запуска приложения. А это ещё несколько часов простоя, пока создастся Slave (хотя и значительно меньше, чем миграция Master).
Поэтому решили попробовать миграцию с помощью логической репликации в PostgreSQL с помощью стороннего плагина под названием pglogical.
### Общая информация
[pglogical](https://www.2ndquadrant.com/en/resources/pglogical/) — это система логической репликации, использующая нативный Logical Decoding в PostgreSQL и реализованная в виде PostgreSQL extension. Позволяет настраивать выборочную репликацию с помощью модели подписок/публикаций. Не требует создания триггеров в базе или использования каких-либо внешних утилит для репликации.
Расширение работает на любой версии PostgreSQL, начиная с 9.4 (поскольку Logical Decoding впервые появился в 9.4), и позволяет осуществлять миграцию между любыми поддерживаемыми версиями PostgreSQL в любом направлении.
Настройка репликации с помощью pglogical вручную не очень тривиальна, хотя в принципе и вполне возможна. К счастью, существует сторонняя утилита [pgrepup](https://github.com/rtshome/pgrepup/) для автоматизации процесса настройки, которой мы и воспользуемся.
### Памятка о свободном месте на диске
Поскольку мы планируем поднимать новую версию PostgreSQL на тех же серверах параллельно со старой, требования к диску под БД на серверах Master и Slave удваиваются. Казалось бы, это очевидно, но… Просто позаботьтесь о достаточном количестве свободного места перед запуском репликации, чтобы не жалеть о бесцельно прожитых годах.
В нашем случае потребовались модификации базы, плюс формат хранения при миграции между 9.6 и 11 «пухнет» не в пользу свежей версии, поэтому место на диске пришлось в итоге увеличивать не в 2, а примерно в 2.2 раза. Хвала LVM, это можно сделать в процессе миграции на лету.
В общем, take care of it.
### Устанавливаем PostgreSQL 11 на Master
> Note: Мы используем Oracle Linux, и всё нижеследующее будет заточено под этот дистрибутив. Не исключено, что другие дистрибутивы Linux потребуют небольшой доработки напильником, но вряд ли она будет существенной.
```
# добавляем репозиторий
yum install https://download.postgresql.org/pub/repos/yum/11/redhat/rhel-7-x86_64/pgdg-oraclelinux11-11-2.noarch.rpm
# устанавливаем пакеты postgresql11
yum install postgresql11 postgresql11-devel postgresql11-server postgresql11-contrib
# инициализируем базу
/usr/pgsql-11/bin/postgresql-11-setup initdb
```
Старый datadir расположен в **/var/lib/pgsql/9.6/data**, новый, соответственно, ложится в **/var/lib/pgsql/11/data**
Копируем настройки доступа (**pg\_hba.conf**) и настройки сервера (**postgresql.conf**) из 9.6 в 11.
Чтобы запустить два сервера PostgreSQL на одной машине, в конфиге **postgresql.conf** 11 версии меняем порт на 15432 (port = 15432).
Здесь нужно плотно подумать, что ещё нужно сделать в новой версии PostgreSQL конкретно в вашем случае, чтобы он запустился с вашим **postgresql.conf** (и ваше приложение могло в итоге с ним работать). В нашем случае требовалось установить в новую версию используемые нами расширения PostgreSQL. Это выходит за рамки статьи, просто сделайте так, чтобы новый PostgreSQL запустился, работал и полностью вас устраивал :)
```
# ставим расширения, тюним конфиги, добавляем shared libraries, whatever...
# ....
# запускаемся
systemctl enable postgresql-11
systemctl start postgresql-11
```
Смотрим в **/var/lib/pgsql/11/data/pg\_log/**. Всё хорошо? Продолжаем!
### Устанавливаем и настраиваем pgrepup
```
# ставим python
yum install python
yum install python2-pip
# ставим pgrepup
pip install pgrepup
# создаём конфигурацию
pgrepup config
```
Нюансы:
1. В качестве **app\_owner** указываем пользователя, под которым запущены серверы PostgreSQL.
2. В качестве **Database** указываем **template1**.
3. **Username** и **Password** — данные для доступа суперюзера. В нашем случае в **pg\_hba.conf** для локальных подключений пользователя **postgres** был прописан метод **trust**, поэтому пароль можно указать произвольный.
### Настраиваем репликацию
```
# запускаем проверку
pgrepup check
```
Получаем на выходе список из множества параметров, которые должны быть настроены требуемым образом.
Пример результатов проверки:
Все ошибки при проверке нужно будет устранить. В настройках обоих серверов должен быть выставлен **wal\_level=LOGICAL** (для работы Logical Decoding), нужные настройки для движка репликации (количество слотов и **wal\_senders**). Подсказки утилиты pgrepup достаточно информативны, по большинству пунктов вопросов возникнуть не должно.
Вносим все необходимые настройки, которые просит pgrepup.
В оба файла **pg\_hba.conf** добавляем права доступа для пользователя, который будет делать репликацию, всё по подсказке pgrepup:
```
host replication pgrepup_replication 127.0.0.1/32 md5
host all pgrepup_replication 127.0.0.1/32 md5
```
### Добавляем Primary Keys
Для работы репликации во всех таблицах должен быть определён Primary Key.
В нашем случае PK был не везде, поэтому на время репликации необходимо его добавить, а по окончании репликации при желании удалить.
Список таблиц без PK, среди прочего, выдаёт `pgrepup check`. Для всех таблиц из этого списка нужно добавить primary key любым приемлемым для вас способом. В нашем случае это было нечто вида:
```
ALTER TABLE %s ADD COLUMN temporary_pk BIGSERIAL NOT NULL PRIMARY KEY
```
У утилиты pgrepup есть встроенная команда для проведения этой операции (`pgrepup fix`), и при её использовании даже подразумевается, что при успешной репликации эти временные колонки будут автоматически удалены. Но, к сожалению, этот функционал так неиллюзорно и феерически глючил на больших базах, что мы решили не использовать его, а сделать эту операцию вручную так, как нам удобно.
### Устанавливаем pglogical extension
Инструкции по установке расширения можно почитать [тут](https://www.2ndquadrant.com/en/resources/pglogical/pglogical-installation-instructions/). Расширение необходимо установить в оба сервера.
```
# добавляем репозитории с нужными нам версиями
curl https://access.2ndquadrant.com/api/repository/dl/default/release/9.6/rpm | bash
curl https://access.2ndquadrant.com/api/repository/dl/default/release/11/rpm | bash
# устанавливаем пакеты
yum install postgresql96-pglogical postgresql11-pglogical
```
Добавляем загрузку библиотеки в **postgresql.conf** обоих серверов:
```
shared_preload_libraries = 'pglogical'
```
### Устанавливаем pgl\_ddl\_deploy extension
Это вспомогательное расширение, которое pgrepup использует для логической репликации DDL.
```
# и его придётся собирать вручную
git clone https://github.com/enova/pgl_ddl_deploy.git
# сборка и установка для старого сервера
PATH=/usr/pgsql-9.6/bin/:$PATH
USE_PGXS=1 make
USE_PGXS=1 make install
make clean
# сборка и установка для нового сервера
PATH=/usr/pgsql-11/bin/:$PATH
make CLANG=true
make install
```
Добавляем загрузку библиотеки в **postgresql.conf** обоих серверов:
```
shared_preload_libraries = 'pglogical,pgl_ddl_deploy'
```
### Проверяем внесённые изменения
```
# перезапускаем новый postgresql
systemctl restart postgresql-11
```
Теперь с помощью `pgrepup check` необходимо убедиться, что с целевым сервером всё стало ок и все замечания касательно целевого сервера полностью устранены.
Если всё хорошо, можно перезапускать старый сервер. Здесь нужно подумать о том, как к перезагрузке сервера БД отнесётся ваше приложение, возможно, следует его предварительно остановить.
```
# перезапускаем
systemctl restart postgresql-9.6
# проверяем
pgrepup check
```
Теперь в выводе команды все до единого пункты должны быть отмечены как ОК.
Казалось бы, можно запускать миграцию, но…
### Правим баги pgrepup
В актуальной версии pgrepup есть несколько багов, делающих миграцию невозможной. Pull request’ы отправлены, но увы, остаются без внимания, поэтому придётся сделать исправления вручную.
Идём в папку установки pgrepup (наш случай — **/usr/lib/python2.7/site-packages/pgrepup/commands/**).
Делай раз. В каждом файле **\*.py** добавляем пропущенные `**kwargs` в описании функции. Картинка лучше тысячи слов:
Коммит [тут](https://github.com/Slach/pgrepup/commit/fe2146af5d8965a7fd6193669923eb9fbe7eaccc).
Делай два. В **setup.py** делаем поиск по «sh -c», два вхождения, все многострочные команды shell нужно сделать однострочными.
Коммит [тут](https://github.com/rtshome/pgrepup/pull/16).
### Запускаем миграцию
```
# подготовка
pgrepup setup
```
Этой командой pgrepup подготавливает оба сервера к запуску репликации, создаёт пользователя, настраивает pglogical, переносит схему БД.
```
# запускаем репликацию
pgrepup start
```
Он сказал «Поехали!» и махнул рукой:
Репликация запущена. Текущую ситуацию можно увидеть с помощью команды `pgrepup status`:
Здесь мы видим, что две БД уже переехали и репликация идёт, а одна ещё в процессе переезда. Теперь остаётся только пить кофе и ждать, пока прокачается весь объём исходной БД.
Попутно можно заглянуть глубже фасада pgrepup и посмотреть, что происходит под капотом. Для пытливых умов вот список запросов в качестве отправной точки:
```
SELECT * FROM pg_replication_origin_status ORDER BY remote_lsn DESC;
SELECT *,pg_xlog_location_diff(s.sent_location,s.replay_location) byte_lag FROM pg_stat_replication s;
SELECT query FROM pg_stat_activity WHERE application_name='subscription_copy'
```
Вдоволь напившись кофе (на тестовом сервере при написании этой статьи миграция ~700Gb данных длилась в районе суток), мы наконец видим такую картину:
И это означает, что пришло время готовить новый Slave.
### Устанавливаем PostgreSQL 11 на Slave
Здесь всё просто и по учебнику, никаких нюансов.
```
# добавляем репозиторий
yum install https://download.postgresql.org/pub/repos/yum/11/redhat/rhel-7-x86_64/pgdg-oraclelinux11-11-2.noarch.rpm
# устанавливаем postgresql 11
yum install postgresql11 postgresql11-devel postgresql11-server postgresql11-contrib
# переливаем данные с нового мастера
su - postgres
pg_basebackup -h db-master.hostname -p 15432 -D /var/lib/pgsql/11/data/ -R -P -U replication -X stream -c fast
```
Копируем настройки доступа (**pg\_hba.conf**) и настройки сервера (**postgresql.conf**) из 9.6 в 11. В конфиге **postgresql.conf** 11 версии меняем порт на 15432 (port = 15432)
```
# запускаем
systemctl enable postgresql-11
systemctl start postgresql-11
```
```
# проверяем статус репликации на Master
SELECT *,pg_wal_lsn_diff(s.sent_lsn,s.replay_lsn) AS byte_lag FROM pg_stat_replication s;
# проверяем статус репликации на Slave
SELECT now()-pg_last_xact_replay_timestamp();
```
### Промежуточные итоги
После всех этих процедур у нас получится вот такая хитрая схема репликаций:
Здесь в качестве последней проверки (ну и, в конце концов, это просто красиво) можно сделать какой-нибудь UPDATE в базу на 9.6 Master и пронаблюдать, как он среплицируется на остальные три сервера.
### Переключение приложения на новую версию PostgreSQL
До сих пор наше приложение ничего не подозревало о новой версии PostgreSQL, пришло время это исправить. Варианты действий здесь принципиально зависят только от двух вещей:
будете ли вы перевешивать новые сервисы на те же порты, на которых работали старые,
и требуется ли вашему приложению перезапуск при перезапуске сервера БД.
Для интереса ответим на оба вопроса «да» и приступим.
Останавливаем приложение.
```
# проверяем, что нет коннектов, например:
SELECT * FROM pg_stat_activity;
```
```
# останавливаем логическую репликацию
# при этом также произойдёт финальная синхронизация sequences.
pgrepup stop
```
```
# чистим за собой все хвосты
pgrepup uninstall
```
```
# на master:
# выключаем старый сервис
systemctl disable postgresql-9.6
# останавливаем оба сервиса, сначала старый, затем новый.
systemctl stop postgresql-9.6
systemctl stop postgresql-11
# на slave:
# выключаем старый сервис
systemctl disable postgresql-9.6
# останавливаем оба сервиса, сначала старый, затем новый.
systemctl stop postgresql-9.6
systemctl stop postgresql-11
```
Возвращаем стандартный порт в конфиге **postgresql.conf** новой версии на Master и Slave.
На новом Slave также меняем порт на стандартный в **recovery.conf**.
Попутно есть предложение от греха подальше поменять порт на становящейся неактивной старой версии:
Выставляем нестандартный порт в **postgresql.conf** старой версии на Master и Slave.
На старом Slave также меняем порт на нестандартный в **recovery.conf**.
```
# запускаем на master
systemctl enable postgresql-11
systemctl start postgresql-11
# запускаем на slave:
systemctl enable postgresql-11
systemctl start postgresql-11
```
Проверяем логи.
Проверяем статус репликации на Master.
```
SELECT *,pg_wal_lsn_diff(s.sent_lsn,s.replay_lsn) AS byte_lag FROM pg_stat_replication s;
```
Запускаем приложение. Радуемся полчаса.
**А напоследок полезная литература по теме:**
* [pglogical](https://www.2ndquadrant.com/en/resources/pglogical/)
* [Installation Instructions for pglogical](https://www.2ndquadrant.com/en/resources/pglogical/pglogical-installation-instructions/)
* [pglogical Docs](https://www.2ndquadrant.com/en/resources/pglogical/pglogical-docs/)
* [Upgrading PostgreSQL from 9.4 to 10.3 with pglogical](https://hunleyd.github.io/posts/Upgrading-PostgreSQL-from-9.4-to-10.3-with-pglogical/)
* [pgrepup – upgrade PostgreSQL using logical replication](http://gasparin.net/2016/11/pgrepup-upgrade-postgresql-using-logical-replication/)
* [pgrepup – PostgreSQL REPlicate and UPgrade](https://github.com/rtshome/pgrepup)
* [Upgrading PostgreSQL from 9.6 to 10 with minimal downtime using pglogical](https://rosenfeld.herokuapp.com/en/articles/infrastructure/2017-11-10-upgrading-postgresql-from-9-6-to-10-with-minimal-downtime-using-pglogical)
Успехов! | https://habr.com/ru/post/437318/ | null | ru | null |
# Создание арта с помощью DCGAN на Keras
Доброго времени суток. Полгода назад я начал изучать машинное обучение, прошел пару курсов и получил некоторый опыт в этом. Затем, видя самые разные новости о том, какие нейронные сети крутые и много могут делать, я решил попробовать изучить их. Начал читать книгу Николенко про глубокое обучение и в ходе чтения у меня появилось несколько идей (которые не новы для мира, но для меня представляли огромный интерес), одна из которых — создать нейросеть, которая генерировала бы для меня арт, который казался бы классным не только мне, "отцу рисующего ребёнка", но и другим людям. В этой статье я постараюсь описать путь, который я прошел для того, чтобы получить первые удовлетворяющие меня результаты.
#### Сбор датасета
Когда я прочитал главу о состязательных сетях, я понял, что теперь могу что-то написать.
Одной из первых задач было написать парсер веб-страницы для сбора датасета. Для этого отлично подошел сайт [wikiart](http://wikiart.org), на нём большое количество картин и все собраны по стилям. Это был мой первый парсер, поэтому я писал его в течение 4-5 дней, первые 3 из которых заняли тыканья по совершенно неправильному пути. Правильный путь был в том, чтобы перейти во вкладку network в исходном коде страницы и отследить, как появляются картинки, при нажатии кнопки "больше". Собственно, для таких же начинающих как я, будет хорошо показать код.
```
from scipy.misc import imresize, imsave
from matplotlib.image import imread
import requests
import json
from bs4 import BeautifulSoup
from itertools import count
import os
import glob
```
В первой ячейке жупитера я импортил нужные библиотеки.
* glob — Удобная штука для получения списка файлов в директории
* requests, BeautifulSoup — Мастхэв для парсинга
* json — библиотека, для получения словаря, который возвращается при нажатии кнопки "больше" на сайте
* resize, save, imread — для чтения изображений и их подготовки.
```
def get_page(style, pagenum):
page = requests.get(url1 + style + url2 + str(pagenum) + url3)
return page
def make_soup(page):
soup = BeautifulSoup(page.text, 'html5lib')
return soup
def make_dir(name, s):
path = os.getcwd() + '/' + s + '/' + name
os.mkdir(path)
```
Описываю функции для удобной работы.
Первая — получает страничку в виде текста, вторая делает этот текст удобнее для работы. Ну и третья для создания нужных папок по стилям.
```
styles = ['kubizm']
url1 = 'https://www.wikiart.org/ru/paintings-by-style/'
url2 = '?select=featured&json=2&layout=new&page='
url3 = '&resultType=masonry'
```
В массиве styles по задумке должно было быть несколько стилей, но так получилось, что я их загружал совсем неравномерно.
```
for style in styles:
make_dir(style, 'images')
for style in styles:
make_dir(style, 'new256_images')
```
Создание нужных папок. Второй цикл создает папки, в котором будут сохранены изображение, сплюснутые в квадрат 256х256.
(Сначала я думал о том, чтобы как-то не нормировать размеры картинок, чтобы не было искажений, но понял, что это либо невозможно, либо слишком сложно для меня)
```
for style in styles:
path = os.getcwd() + '\\images\\' + style + '\\'
images = []
names = []
titles = []
for pagenum in count(start=1):
page = get_page(style, pagenum)
if page.text[0]!='{': break
jsons = json.loads(page.text)
paintings = jsons['Paintings']
if paintings is None: break
for item in paintings:
images_temp = []
images_dict = item['images']
if images_dict is None:
images_temp.append(item['image'])
names.append(item['artistName'])
titles.append(item['title'])
else:
for inner_item in item['images']:
images_temp.append(inner_item['image'])
names.append(item['artistName'])
titles.append(item['title'])
images.append(images_temp)
for char in ['/','\\','"', '?', ':','*','|','<','>']:
titles = [title.replace(char, ' ') for title in titles]
for listimg, name, title in zip(images, names, titles):
if len(name) > 30:
name = name[:25]
if len(title) > 50:
title = title[:50]
if len(listimg) == 1:
response = requests.get(listimg[0])
if response.status_code == 200:
with open(path + name + ' ' + title + '.png', 'wb') as f:
f.write(response.content)
else: print('Error from server')
else:
for i, img in enumerate(listimg):
response = requests.get(img)
if response.status_code == 200:
with open(path + name + ' ' + title + str(i) + '.png', 'wb') as f:
f.write(response.content)
else: print('Error from server')
```
Здесь происходит скачивание картинок и их сохранение в нужную папку. Здесь картинки не меняют размера, сохраняются оригиналы.
Интересные вещи происходят в первом вложенном цикле:
Я решил в тупую постоянно просить json'ы (json — словарь, который возвращает сервер при нажатии кнопки "Больше". В словаре вся информация о картинах), а останавливаться тогда, когда сервер будет возвращать что-то невнятное и не похожее на типичные значения. В данном случае, первый символ возвращаемого текста должен был быть открывающейся фигурной скобкой, после которой идёт тело словаря.
Также было замечено, что сервер может возвращать что-то типа альбома картин. То есть по сути массив картин. Поначалу думал, что возвращаются одинарные картины, имя художников к ним, а может быть так, что разом с одним именем художника дается массив картин.
```
for style in styles:
directory = os.getcwd() + '\\images\\' + style + '\\'
new_dir = os.getcwd() + '\\new256_images\\' + style + '\\'
filepaths = []
for dir_, _, files in os.walk(directory):
for fileName in files:
#relDir = os.path.relpath(dir_, directory)
#relFile = os.path.join(relDir, fileName)
relFile = fileName
#print(directory)
#print(relFile)
filepaths.append(relFile)
#print(filepaths[-1])
print(filepaths[0])
for i, fp in enumerate(filepaths):
img = imread(directory + fp, 0) #/ 255.0
img = imresize(img, (256, 256))
imsave(new_dir + str(i) + ".png", img)
```
Здесь изображения меняют размер и сохраняются в приготовленную для них папку.
Что ж, датасет собран, можно приступать к наиболее интересному !
#### Начиная с малого
Далее, прочитав [исходную статью](https://arxiv.org/pdf/1511.06434.pdf) я начал творить! Но каково же было моё разочарование, когда ничего хорошего не получалось. В эти попытки я обучал сеть на одном стиле картин, но даже так ничего не получалось, поэтому я решил для начала научиться генерировать цифры из мниста. Не буду здесь подробно останавливаться, расскажу только об архитектуре и переломном моменте, благодаря которому начали генерироваться цифры.
```
def build_generator():
model = Sequential()
model.add(Dense(128 * 7 * 7, input_dim = latent_dim))
model.add(BatchNormalization())
model.add(LeakyReLU())
model.add(Reshape((7, 7, 128)))
model.add(Conv2DTranspose(64, filter_size, strides=(2,2), padding='same'))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU())
model.add(Conv2DTranspose(32, filter_size, strides=(1, 1), padding='same'))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU())
model.add(Conv2DTranspose(img_channels, filter_size, strides=(2,2), padding='same'))
model.add(Activation("tanh"))
model.summary()
return model
```
* latent\_dim — массив из 100 рандомно сгенерированных чисел.
```
def build_discriminator():
model = Sequential()
model.add(Conv2D(64, kernel_size=filter_size, strides = (2,2), input_shape=img_shape, padding="same"))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(Conv2D(128, kernel_size=filter_size, strides = (2,2), padding="same"))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(Conv2D(128, kernel_size=filter_size, strides = (2,2), padding="same"))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(1))
model.add(Activation('sigmoid'))
model.summary()
return model
```
То есть по итогу размеры выходов свёрточных слоёв и количество слоёв вообще меньше, чем в исходной статье. 28х28 ведь генерирую, а не интерьеры !
Ну и тот самый трюк, благодаря которому всё получилось — на четной итерации обучения дискриминатор смотрел на сгенерированные картинки, а на нечетной — на реальные.
На этом в общем-то всё. Подобный DCGAN обучился весьма быстро, например, картинка в начале данной подтемы была получена на 19 эпохе,
Эти уже уверенные, но тем не менее временами не реальные цифры получились на 99 эпохе обучения.
Удовлетворившись предварительным результатом я остановил обучение и начал думать над тем, как же решить основную задачу.
#### Creative adversarial network
Следующим шагом было чтение о GAN с лейблами: дискриминатору и генератору подается класс текущей картинки. А после гана с лейблами я узнал о [CAN](https://arxiv.org/pdf/1706.07068.pdf) — расшифровка в общем-то в названии подтемы.
В CAN дискриминатор пытается угадать класс картины, если картина из реального сета. И, соответственно, в случае обучения на реальной картине в качестве ошибки дискриминатору кроме дефолтной подается ошибка от угадывания класса.
При обучении на сгенерированной картинке дискриминатору нужно только предсказать, реальная эта картинка или нет.
Генератору же, кроме того, чтобы просто обмануть дискриминатор, нужно сделать так, чтобы дискриминатор был в растерянности при угадывании класса картинки, то есть генератор будет интересовать то, чтобы выходы на классы дискриминаторы были как можно дальше от 1, полной уверенности.
Переходя к CAN я опять же испытывал трудности, дизмораль из-за того, что ничего не работает и не обучается. Спустя несколько неприятных провалов, решил начать всё с начала и сохранять все изменения (Да, раньше этого не делал), веса и архитектуру (для прерывания обучения).
Сначала я захотел сделать сеть, которая генерировала бы мне одну-единственную картинку размера 256х256 (Все следующие картинки такого размера) без всяких лейблов. Переломный момент здесь был в том, чтобы наоборот в каждой итерации обучения дискриминатору давать смотреть и на сгенерированные картинки, и на реальные.
Это результат, на котором я остановился и перешел к следующему этапу. Да, цвета отличаются от реальной картины, но меня больше интересовало умение сети выделять контуры и объекты. С этим она справилась.
Дальше можно было приступать к основной задаче — генерированию арта. Сразу представлю код, попутно комментируя его.
Сначала как всегда нужно импортировать все библиотеки.
```
import glob
from PIL import Image
from keras.preprocessing.image import array_to_img, img_to_array, load_img
from datetime import date
from datetime import datetime
import tensorflow as tf
import numpy as np
import argparse
import math
import os
from matplotlib.image import imread
from scipy.misc.pilutil import imresize, imsave
import matplotlib.pyplot as plt
import cv2
import keras
from keras.models import Sequential, Model
from keras.layers import Dense, Activation, Reshape, Flatten, Dropout, Input
from keras.layers.convolutional import Conv2D, Conv2DTranspose, MaxPooling2D
from keras.layers.normalization import BatchNormalization
from keras.layers.advanced_activations import LeakyReLU
from keras.optimizers import Adam, SGD
from keras.datasets import mnist
from keras import initializers
import numpy as np
import random
```
Создание генератора.
Выходы слоёв опять же отличаются от статьи. Где-то в целях экономии памяти (Условия: домашний компьютер с gtx970), а где-то из-за успеха с конфигурацией
```
def build_generator():
model = Sequential()
model.add(Dense(128 * 16 * 8, input_dim = latent_dim))
model.add(BatchNormalization())
model.add(LeakyReLU())
model.add(Reshape((8, 8, 256)))
model.add(Conv2DTranspose(512, filter_size_g, strides=(1,1), padding='same'))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU())
model.add(Conv2DTranspose(512, filter_size_g, strides=(1,1), padding='same'))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU())
model.add(Conv2DTranspose(256, filter_size_g, strides=(1,1), padding='same'))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU())
model.add(Conv2DTranspose(128, filter_size_g, strides=(2,2), padding='same'))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU())
model.add(Conv2DTranspose(64, filter_size_g, strides=(2,2), padding='same'))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU())
model.add(Conv2DTranspose(32, filter_size_g, strides=(2,2), padding='same'))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU())
model.add(Conv2DTranspose(16, filter_size_g, strides=(2,2), padding='same'))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU())
model.add(Conv2DTranspose(8, filter_size_g, strides=(2,2), padding='same'))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU())
model.add(Conv2DTranspose(img_channels, filter_size_g, strides=(1,1), padding='same'))
model.add(Activation("tanh"))
model.summary()
return model
```
Функция создания дискриминатора возвращает две модели, одна из которых пытается узнать, реальная ли картинка, а другая пытается узнать класс картинки.
```
def build_discriminator(num_classes):
model = Sequential()
model.add(Conv2D(64, kernel_size=filter_size_d, strides = (2,2), input_shape=img_shape, padding="same"))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(Conv2D(128, kernel_size=filter_size_d, strides = (2,2), padding="same"))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(Conv2D(256, kernel_size=filter_size_d, strides = (2,2), padding="same"))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(Conv2D(512, kernel_size=filter_size_d, strides = (2,2), padding="same"))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(Conv2D(512, kernel_size=filter_size_d, strides = (2,2), padding="same"))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(Conv2D(512, kernel_size=filter_size_d, strides = (2,2), padding="same"))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(Flatten())
model.summary()
img = Input(shape=img_shape)
features = model(img)
validity = Dense(1)(features)
valid = Activation('sigmoid')(validity)
label1 = Dense(1024)(features)
lrelu1 = LeakyReLU(alpha=0.2)(label1)
label2 = Dense(512)(label1)
lrelu2 = LeakyReLU(alpha=0.2)(label2)
label3 = Dense(num_classes)(label2)
label = Activation('softmax')(label3)
return Model(img, valid), Model(img, label)
```
Функция для создания состязательной модели. В состязательной модели дискриминатор не обучается.
```
def generator_containing_discriminator(g, d, d_label):
noise = Input(shape=(latent_dim,))
img = g(noise)
d.trainable = False
d_label.trainable = False
valid, target_label = d(img), d_label(img)
return Model(noise, [valid, target_label])
```
Функция для загрузки батча с реальными картинками и лейблами. data — массив адресов, который будет определён позже. В этой же функции производится нормализация картинки.
```
def get_images_classes(batch_size, data):
X_train = np.zeros((batch_size, img_rows, img_cols, img_channels))
y_labels = np.zeros(batch_size)
choice_arr = np.random.randint(0, len(data), batch_size)
for i in range(batch_size):
rand_number = np.random.randint(0, len(data[choice_arr[i]]))
temp_img = cv2.imread(data[choice_arr[i]][rand_number])
X_train[i] = temp_img
y_labels[i] = choice_arr[i]
X_train = (X_train - 127.5)/127.5
return X_train, y_labels
```
Функция для красивого вывода батча картинок. Собственно, все картинки из этой статьи были собраны этой функцией.
```
def combine_images(generated_images):
num = generated_images.shape[0]
width = int(math.sqrt(num))
height = int(math.ceil(float(num)/width))
shape = generated_images.shape[1:3]
image = np.zeros((height*shape[0], width*shape[1], img_channels),
dtype=generated_images.dtype)
for index, img in enumerate(generated_images):
i = int(index/width)
j = index % width
image[i*shape[0]:(i+1)*shape[0], j*shape[1]:(j+1)*shape[1]] = \
img[:, :, :,]
return image
```
А здесь эта самая data. Она в более-менее удобном виде возвращает набор адресов картинок, которые мы, выше, разложили по папкам
```
def get_data():
styles_folder = os.listdir(path=os.getcwd() + "\\new256_images\\")
num_styles = len(styles_folder)
data = []
for i in range(num_styles):
data.append(glob.glob(os.getcwd() + '\\new256_images\\' + styles_folder[i] + '\\*'))
return data, num_styles
```
Для прохождении эпохи выставлено рандомное большое число, потому что посчитать количество всех картинок было лень. В этой же функции предусмотрена загрузка весов, если нужно продолжить обучение. Каждые 5 эпох веса и архитектура сохраняются.
Также стоит написать, что я пробовал добавлять шум на входные картинки, но в последнее обучение решил этого не делать.
Использованы сглаженные метки классов, они весьма заметно помогают обучению.
```
def train_another(epochs = 100, BATCH_SIZE = 4, weights = False, month_day = '', epoch = ''):
data, num_styles = get_data()
generator = build_generator()
discriminator, d_label = build_discriminator(num_styles)
discriminator.compile(loss=losses[0], optimizer=d_optim)
d_label.compile(loss=losses[1], optimizer=d_optim)
generator.compile(loss='binary_crossentropy', optimizer=g_optim)
if month_day != '':
generator.load_weights(os.getcwd() + '/' + month_day + epoch + ' gen_weights.h5')
discriminator.load_weights(os.getcwd() + '/' + month_day + epoch + ' dis_weights.h5')
d_label.load_weights(os.getcwd() + '/' + month_day + epoch + ' dis_label_weights.h5')
dcgan = generator_containing_discriminator(generator, discriminator, d_label)
dcgan.compile(loss=losses[0], optimizer=g_optim)
discriminator.trainable = True
d_label.trainable = True
for epoch in range(epochs):
for index in range(int(15000/BATCH_SIZE)):
noise = np.random.normal(0, 1, (BATCH_SIZE, latent_dim))
real_images, real_labels = get_images_classes(BATCH_SIZE, data)
#real_images += np.random.normal(size = img_shape, scale= 0.1)
generated_images = generator.predict(noise)
X = real_images
real_labels = real_labels - 0.1 + np.random.rand(BATCH_SIZE)*0.2
y_classif = keras.utils.to_categorical(np.zeros(BATCH_SIZE) + real_labels, num_styles)
y = 0.8 + np.random.rand(BATCH_SIZE)*0.2
d_loss = []
d_loss.append(discriminator.train_on_batch(X, y))
discriminator.trainable = False
d_loss.append(d_label.train_on_batch(X, y_classif))
print("epoch %d batch %d d_loss : %f, label_loss: %f" % (epoch, index, d_loss[0], d_loss[1]))
X = generated_images
y = np.random.rand(BATCH_SIZE) * 0.2
d_loss = discriminator.train_on_batch(X, y)
print("epoch %d batch %d d_loss : %f" % (epoch, index, d_loss))
noise = np.random.normal(0, 1, (BATCH_SIZE, latent_dim))
discriminator.trainable = False
d_label.trainable = False
y_classif = keras.utils.to_categorical(np.zeros(BATCH_SIZE) + 1/num_styles, num_styles)
y = np.random.rand(BATCH_SIZE) * 0.3
g_loss = dcgan.train_on_batch(noise, [y, y_classif])
d_label.trainable = True
discriminator.trainable = True
print("epoch %d batch %d g_loss : %f, label_loss: %f" % (epoch, index, g_loss[0], g_loss[1]))
if index % 50 == 0:
image = combine_images(generated_images)
image = image*127.5+127.5
cv2.imwrite(
os.getcwd() + '\\generated\\epoch%d_%d.png' % (epoch, index), image)
image = combine_images(real_images)
image = image*127.5+127.5
cv2.imwrite(
os.getcwd() + '\\generated\\epoch%d_%d_data.png' % (epoch, index), image)
if epoch % 5 == 0:
date_today = date.today()
month, day = date_today.month, date_today.day
# Генерируем описание модели в формате json
d_json = discriminator.to_json()
# Записываем модель в файл
json_file = open(os.getcwd() + "/%d.%d dis_model.json" % (day, month), "w")
json_file.write(d_json)
json_file.close()
# Генерируем описание модели в формате json
d_l_json = d_label.to_json()
# Записываем модель в файл
json_file = open(os.getcwd() + "/%d.%d dis_label_model.json" % (day, month), "w")
json_file.write(d_l_json)
json_file.close()
# Генерируем описание модели в формате json
gen_json = generator.to_json()
# Записываем модель в файл
json_file = open(os.getcwd() + "/%d.%d gen_model.json" % (day, month), "w")
json_file.write(gen_json)
json_file.close()
discriminator.save_weights(os.getcwd() + '/%d.%d %d_epoch dis_weights.h5' % (day, month, epoch))
d_label.save_weights(os.getcwd() + '/%d.%d %d_epoch dis_label_weights.h5' % (day, month, epoch))
generator.save_weights(os.getcwd() + '/%d.%d %d_epoch gen_weights.h5' % (day, month, epoch))
```
Инициализация переменных и запуск обучение. Из-за низкой "мощности" моего компьютера обучение возможно максимум на батче размером в 16 картинок.
```
img_rows = 256
img_cols = 256
img_channels = 3
img_shape = (img_rows, img_cols, img_channels)
latent_dim = 100
filter_size_g = (5,5)
filter_size_d = (5,5)
d_strides = (2,2)
color_mode = 'rgb'
losses = ['binary_crossentropy', 'categorical_crossentropy']
g_optim = Adam(0.0002, beta_2 = 0.5)
d_optim = Adam(0.0002, beta_2 = 0.5)
train_another(1000, 16)
```
Вообще я довольно давно хочу написать пост на хабре про эту свою идею, сейчас не самое лучшее для этого время, потому что эта нейронка обучается в течение трёх дней и сейчас находится на 113 эпохе, но сегодня я обнаружил интересные картинки, поэтому решил, что пора бы уже писать пост !
Вот такие картинки получились на сегодняшний день. Возможно, назвав их, я смогу передать читателю моё личное восприятие этих картинок. Вполне заметно, что сеть не обучена достаточно (или может вообще такими методами не обучится), особенно учитывая то, что картинки взяты черрипикингом, но сегодня я получил результат, который мне понравился.
В дальнейших планах дообучить эту конфигурацию до момента, когда станет ясно, на что она способна. Также в планах создание сети, которая бы увеличивала эти картинки до вменяемых размеров. Такое уже придумали и реализации есть.
Буду чрезвычайно рад конструктивной критике, хорошим советам и вопросам. | https://habr.com/ru/post/431614/ | null | ru | null |
# Проблемы работы модулей в Joomla 1.5 с использованием двух и более шаблонов и компонента Joomfish
В моей практике часто случалось использовать два и более шаблона для Жумла сайтов. В Joomla 1.5 это вполне удобно реализовано, один шаблон выбирается default (применяемый ко всем новосозданным пунктам меню), а второй «выборочный».Обычно само содержимое в этом случае публикуется именно на default шаблоне. Делается это все довольно просто и быстро, но есть и свои минусы. Об одном из них я хотел рассказать в этом посте.
Дело в том, что при публикации модуля (поиск, новости) на главной, и в случае если она же является у нас «выборочной», т.е. содержимое вызывается в другом шаблоне, происходит интересная штука. Каждой из новостей присваивается Itemid соответствующий меню в котором опубликован модуль, а для главной это «1». Тем самым Жумла пытается открыть этот урл под этим Itemid, а так как он не содержит вызова содержимого, то перехода на внутреннюю страницу не происходит, новость не выводится, т.е все остается без изменений. Я не знаком, тесно, с Жумлавским АПИ, но для меня это стало очень неприятным сюрпризом. Гибкость Жумлы в плане независимости элементов структуры от элементов содержимого была одним из тех факторов за которым я и взялся за изучение движка. Причем, данный процесс стал проявляться только после установки компонента Joomfish. Тем не менее выход необходимо было находить. Выход я нашел возможно не самый правильный, но рабочий. Долго мучаясь над этим Itemid=1, я решил избавиться от него. Дабы не вызвать конфликтов приравнял Itemid к «0» (Дело в том что приравнивая Itemid к другим значениям не равным нулю я рисковал присвоить его существующему элементу структуры (меню), а единица является самым первым элементом, т.е
«0» абсолютно свободен.) Ниже я приведу изменения сделанные в файле mod\_newsflash/helper.php
Оригинальный код:
`$item->linkOn = JRoute::_(ContentHelperRoute::getArticleRoute($item->slug, $item->catslug, $item->sectionid));`
В данной строчке и происходит «сборка» УРЛА новости (порядковый номер статьи id, название статьи, порядковый номер категории catid, а так же порядковый номер элемента структуры(меню) Itemid).
Все что я сделал, это «насильно» присвоил «0» Itemid всех элементов. Таким образом моя новость перестала принадлежать какому-либо меню.
Код:
`$item->linkOn = JRoute::_(ContentHelperRoute::getArticleRoute($item->slug, $item->catslug.'&Itemid=0', $item->sectionid));`
После этого изменения, все новости стали переходить по своим внутренним ссылкам, т.е стали вызываться default шаблоном.
Похожее изменение удалось сделать и модулю поиска, только на этот раз пришлось править компонент.
Открыв файл components/com\_search/controller.php сделал изменения в этой строчке:
`$this->setRedirect(JRoute::_('index.php'.$uri->toString(array('query', 'fragment')), false));`
Заменил на:
`$this->setRedirect(JRoute::_('index.php'.$uri->toString(array('query', 'fragment')).'&Itemid=0', false));`
Опять же насильственно присвоив ей Itemid=0
Много деталей при написании поста я упустил, но суть передать удалось. Возможно этот метод не является грамотным, но своего я добился, а для меня это главное.
Спасибо! | https://habr.com/ru/post/123874/ | null | ru | null |
# Решение проблемы с созданием нового скрипта
Суть её такова: Если в имени пользователя Windows используется кириллица, то при создании нового скрипта(из меню Greasemonkey) его файл не открывается в редакторе из-за неверного пути.
Покопавшись в исходниках Greasemonkey, было найдено решение.
1. Идём в папку с дополнениями Firefox. У меня это C:\Users\Кирилл\AppData\Roaming\Mozilla\Firefox\Profiles\rwlkyo8j.default\extensions
2. Находим папку с Greasemonkey. Она будет называться приблизительно так: *{e4a8a97b-f2ed-450b-b12d-ee082ba24781}* :) Если у Вас папок с подобным названием много, то есть смысл воспользоваться поиском по ключевому слову *greasemonkey* и выявить таким образом нужную нам папку.
3. Далее переходим в директорию *content* и открываем файл *utils.js*. Находим функцию *launchApplicationWithDoc* и добавляем код:
> `var converter = Components.classes['@mozilla.org/intl/scriptableunicodeconverter']
>
> .createInstance(Components.interfaces.nsIScriptableUnicodeConverter);
>
> converter.charset = "windows-1251";
>
> args = [converter.ConvertFromUnicode(args)];
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Перед строчкой:
> `var process = Components.classes["@mozilla.org/process/util;1"]
>
> .createInstance(Components.interfaces.nsIProcess);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Надеюсь, что кому-то это будет полезно. Спасибо за внимание. | https://habr.com/ru/post/73908/ | null | ru | null |
# Анализ тональности в социальных медиа на русском языке при помощи RussianSentimentAnalyzer API
В этом посте я покажу, как воспользоваться [API](https://www.mashape.com/dmitrykey/russiansentimentanalyzer) анализа тональности в социальных медиа на русском языке. Одной из отличительных фич системы является возможность определять тональность по отношению к заданному объекту мониторинга. Проиллюстрирую на примере:
```
Мне нравится телефон X, но телефон Y ужасен.
```
Логично ожидать, что если мы интересуемся телефонами X, то хотим получить позитивную метку тональности. И негативную для телефона Y. Именно такой результат вы получите, введя это предложение на сайте [www.mashape.com/dmitrykey/russiansentimentanalyzer](https://www.mashape.com/dmitrykey/russiansentimentanalyzer) (понадобится регистрация) и указав в качестве объектов X либо Y.
Ниже вы найдёте пример кода на Java, который позволяет легко подключиться к API, послать запрос и получить результат. Этот и другие примеры взаимодействия с нашими системами можно найти на нашем [гитхабе](https://github.com/semanticanalyzer/nlproc_sdk_sample_code).
```
package com.semanticanalyzer;
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.JsonNode;
import com.mashape.unirest.http.Unirest;
import com.mashape.unirest.http.exceptions.UnirestException;
public class RussianSentimentAnalyzerMashapeClient {
private final static String mashapeKey = "ВАШ_MASHAPE_KEY_ЗДЕСЬ";
public static void main(String[] args) throws UnirestException {
String textToAnnotate = "'ВТБ кстати неплохой банк)'";
String targetObject = "'ВТБ'";
// These code snippets use an open-source library. http://unirest.io/java
HttpResponse response = Unirest.post("https://russiansentimentanalyzer.p.mashape.com/ru/sentiment/polarity/json/")
.header("X-Mashape-Key", mashapeKey)
.header("Content-Type", "application/json")
.header("Accept", "application/json")
.body("{'text':" + textToAnnotate + ",'object_keywords':" + targetObject + ",'output_format':'json'}")
.asJson();
System.out.println("Input text = " + textToAnnotate + "\n" + "Target object: " + targetObject);
System.out.println("RussianSentimentAnalyzer response:" + response.getBody().toString());
}
}
```
Если запрос обработался успешно, то система выдаст следующий результат:
```
Input text = 'ВТБ кстати неплохой банк)'
Target object: 'ВТБ'
RussianSentimentAnalyzer response:{"sentiment":"POSITIVE","synonyms":"[ВТБ]"}
```
Помимо Java на сайте API можно найти примеры для других языков: Node, PHP, Python, Objective-C, Ruby и .NET. | https://habr.com/ru/post/262213/ | null | ru | null |
# «Идеальный» кластер. Часть 3.1 Внедрение MySQL Multi-Master кластера
#### В продолжение цикла статей об «Идеальном» кластере хочу поделиться моим опытом развертывания и настройки Multi-Master кластеров MySQL.
**Другие мои публикации на тему «Идеального» кластера**
* [Ускорение и оптимизация PHP-сайта. Какие технологии стоит выбирать при настройке сервера под PHP](http://habrahabr.ru/post/264487/)
* [«Идеальный» кластер. Часть 3.1 Внедрение MySQL Multi-Master кластера](http://habrahabr.ru/post/253869/)
* [«Идеальный» кластер. Часть 2.2: Высокодоступный и масштабируемый web-сервер, лучшие технологии на страже вашего бизнеса](http://habrahabr.ru/company/acronis/blog/209934/)
* [О виртуальном кластере на hetzner](http://habrahabr.ru/company/acronis/blog/204190/)
* [Frontend: NGINX + Keepalived (vrrp) на CentOS](http://habrahabr.ru/company/acronis/blog/198934/)
* [HAPRoxy для Percona или Galera на CentOS. Его настройка и мониторинг в Zabbix](http://habrahabr.ru/company/acronis/blog/198448/)
* [Zabbix 2.2 верхом на nginx + php-fpm и mariadb](http://habrahabr.ru/company/acronis/blog/198354/)
Для начала стоит разобраться с тем, какой из реализацией технолгии MySQL Galera, Вы будете пользоватся. На рынке есть имплементации Galera от Percona и MariaDB. Именно эти две реализации и поделили львиную долю внедрений MySQL Galera.
**Оба форка используют в качестве плагина InnoDB, движок Percona XtraDB Storage Engine.**
> Этот движок основан на коде InnoDB-plugin и полностью совместимый с ним, но отличается заметно более высокой производительностью, благодаря интеграции патчей от компаний Google и Percona.
>
> В частности, в XtraDB улучшен механизм работы с памятью, улучшена работа подсистемы ввода/вывода InnoDB, добавлена поддержка нескольких потоков чтения и записи, поддержка управления пропускной способностью,
>
> реализация упреждающей выборкой данных (read-ahead), адаптивная установка контрольных точек (adaptive checkpointing), расширены возможности по масштабированию для больших проектов, система организации блокировок адаптирована
>
> для работы на системах с большим числом CPU, добавлены дополнительные возможности для накопления и анализа статистики.
При этом, **MariaDB Galera отличается целым рядом других улучшений и возможностей**.
* **Aria (ранее Maria)** — основанное на MyISAM высоконадежное хранилище, отличающееся повышенной устойчивостью и сохранению целостности данных после краха, при полной совместимости с MyISAM. Благодаря ведению лога операций, в случае краха производится откат результатов выполнения текущей операции. Также поддерживается возможность восстановления состояния из любой точки в логе операций (включая поддержку CREATE/DROP/RENAME/TRUNCATE).
* **PBXT (PrimeBase XT)** — хранилище, разработанное с нуля и поддерживающее мультиверсионный метод организации хранения данных MVCC (multi-version concurrency control), позволяющий избавиться от блокировок при выполнении операций чтения.
PBXT поддерживает ACID-совместимые транзакции, быстрый откат транзакций и восстановление после некорректного завершения работы сервера. Имеются средства для обеспечения ссылочной целостности данных, поддержка определения внешних ключей (foreign key), каскадных обновлений и удалений данных. Поддерживается возможность прямого потокового ввода и вывода бинарных данных (BLOB) в БД;
* **FederatedX** — позиционируется в качестве замены разработанного в Sun Microsystems и уже не поддерживаемого хранилища Federated. FederatedX позволяет организовать обращение к удаленным таблицам как к локальным.
Имеется поддержка транзакций, одновременной установки нескольких соединений к удаленной СУБД, использования операций «LIMIT»;
* **OQGRAPH** — хранилище для организации иерархических (древовидных) структур и сложных графов (узлов, имеющих множество связей);
* **Sphinx** — хранилище для построения поисковых движков. Встроенный Sphinx-клиент позволяет MariaDB обмениваться данными с searchd, выполнять поисковые запросы и получать результаты поиска;
Кроме того, **в MariaDB Galera 10** появился целый ряд улучшений по сравнению с версией 5.5:
* Новое хранилище **Connect**, позволяющее организовать доступ к произвольным локальным или удалённым данным, в виде, как если бы они были сохранены в таблице. Например можно ассоциировать содержимое виртуальной таблицы с данными из файла в определённом формате;
* Новое хранилище **Cassandra Storage Engine (SE)**, добавляющее в MariaDB и MySQL поддержку средств для доступа к данным, хранимым в распределённой БД Apache Cassandra. Используя Cassandra SE разработчики получают возможность обращаться к данным и добавлять данные в БД Cassandra при помощи обычных SQL-запросов. При этом используемая в Cassandra модель хранения данных в виде семейства столбцов (ColumnFamily) отображается в форме свойственных для MariaDB/MySQL таблиц, для которых можно применять стандартные SQL-директивы SELECT, INSERT, DELETE и UPDATE, а также выполнять операции объединения (JOIN) с другими таблицами.
* Интеграция хранилища **SPIDER** с реализацией системы шардинга, позволяющей разносить большие таблицы на несколько серверов. С точки зрения формирования запросов такие таблицы не отличаются от обычных локальных таблиц, но фактически при использовании SPIDER разные порции данных, составляющих одну таблицу, хранятся на разных серверах. Для обеспечения высокой доступности таблиц, распределённых по серверам при помощи SPIDER, могут применяться новые средства репликации.
* Хранилище **Sequence** для формирования виртуальных таблиц, заполненных возрастающими или убывающими последовательностями (например, seq\_1\_to\_5 или seq\_5\_to\_1\_step\_2).
* Улучшенная реализация динамических столбцов, позволяющих получить различный набор «виртуальных столбцов» для каждой строки в таблице.
* Добавлена поддержка запросов в формате JSON и возможность интеграции с БД Cassandra;
* Многочисленные оптимизации производительности, позволяющие в MariaDB 10 добиться многократного ускорения некоторых операций по сравнению с MySQL и прошлыми ветками MariaDB. Среди ключевых оптимизаций отмечается поддержка **параллельной репликации** и развитие системы групповых коммитов. Добавлены дополнительные оптимизации выполнения вложенных запросов, например преобразование выражений «NOT EXISTS» в блоки «IN»;
* Улучшены средства репликации. Обеспечена защита работы реплицируемых slave-серверов от проблем в случае краха.
* **Добавлена поддержка репликации данных от нескольких master-серверов (multi-source репликации)**. Из примеров использования multi-source репликации упоминается решение задач сбора в одном месте данных, разнесённых на разные машины, с целью выполнения аналитических запросов или для создания резервной копии;
* Поддержка глобальных идентификаторов транзакций;
* Возможность использования проверки IF (NOT) EXIST для выражений ALTER TABLE;
* Улучшенный вывод сообщений об ошибках. Все числовые номера ошибок теперь сопровождаются пояснительными текстами.
* Поддержка выражения «SHOW EXPLAIN FOR thread\_id» для анализа запроса, выполняемого в заданной нити. Так как «SHOW EXPLAIN» учитывает план выполнения оптимизатором реального запроса, он позволяет получить более близкие к реальности показатели, чем выполнение запроса внутри «EXPLAIN»;
* В InnoDB добавлены дополнительные оптимизации, позволяющие зметно ускорить выполнения транзакций, не выполняющих операции записи и изменения данных. Для выполнения транзакций в режиме чтения добавлена новая команда «TRANSACTION READ ONLY»;
* Оптимизировано выполнение конструкции «LIMIT… ORDER BY»;
* Поддержка автоматического обновления времени (timestamp) в DATETIME;
* Хранимые в памяти таблицы с эффективной поддержкой типов VARCHAR и BLOB;
* Универсальная система накопления статистики об активности и наполнении таблиц для использования оптимизатором запросов, реализованная без привязки к конкретным движкам хранения;
* Поддержка анализа потребления памяти в привязке к отдельной нити;
* Значительное ускорение работы конструкций ALTER TABLE для хранилищ Aria и MyISAM при наличии проверки уникальных ключей;
**Улучшения портированные из MySQL 5.6:**
* Обновлённый вариант хранилища InnoDB.
* Поддержка движка PERFORMANCE\_SCHEMA и связанной с ним базы performance\_schema, предоставляющей низкоуровневые средства для мониторинга за выполнением запросов и различными событиями при работе СУБД;
* Режим только для чтения для транзакций в InnoDB, поддержка выражения «TRANSACTION READ ONLY»;
* Оптимизации скорости выполнения запросов вида «ORDER BY… LIMIT».
* Поддержка "--plugin-load-add";
* Возможность выполнения «ALTER TABLE» на лету;
* Установка привилегий для временных таблиц;
* Расширения, связанные с поддержкой кодировок;
* Выражение «GET DIAGNOSTICS»;
* Временные литералы (например, TIME'12:34:56').
От себя хочу добавить, что оба форка так же поддерживают **HandlerSocket** и **Memcached plugin**
Более подробное описание стабильного выпуска СУБД MariaDB 10.0, можно найти в [**источнике на opennet**](http://www.opennet.ru/opennews/art.shtml?num=39444)
#### **Почему я выбрал MariaDB Galera 10?**
.
MariaDB Galera 10 поддерживает **MySQL Query Cache** из коробки. Любая инструкция по установке любой из имплементаций MySQL Galera, явно указывает о необходимости отключения Query Cache. В итоге, при переходе с одиночного сервера баз данных на кластерный вариант, скорость чтения сложных запросов падает в разы. А нагрузка на сервер, соизмеримо возрастает.
Percona XtraDB Cluster в версии 5.6 так же приблизились к внедрению полноценного поддержки Query Cache, но тут требуется включать его на «живую», уже после запуска ноды при помощи запросов:
```
SET GLOBAL query_cache_size =128*1024*1024;
SET GLOBAL query_cache_type = 1;
```
При включенном Query Cache, до 95% запросов возвращают результат из кеша вместо того что бы выполняются снова.
**Хочу сразу дать пару своих замечаний.**
**Кеша не должно быть много**. Самый большой размер, который вообще стоит устанавливать, это не более **512МБ**. Даже 512МБ — это очень много, реально нужно меньше. И вот почему:
> **Если в любой из таблиц, выборка из которой есть в кеше, проиcходят изменения (вставка или изменение строк), то MySQL удаляет из кеша такие выборки**. Такой подход ускоряет работу MySQL, но может быть неэффективным для систем с большим количеством запросов на изменение таблиц. Это приводит к тому, что таблицы просто блокируются в режиме **Waiting for query cache lock**.
Кеш запросов можно представлять себе как хеш, ключами которого являются запросы, а значениями — результаты запросов.
Если использование кеша запросов включено, то при получении запроса MySQL определяет, равны ли первые три символа запроса «SEL». Если да, то MySQL смотрит, есть ли в кеше запросов запись с ключом, равным запросу.
**Отсюда следуют два важных правила:**
* MySQL выполняет побайтовое сравнение, поэтому запросы, имеющие отличие хотя бы в одном символе (например, SELECT \* FROM table и select \* from table) будут рассматриваться как два разных запроса. Поэтому необходимо писать запросы в едином стиле;
* В MySQL до версии 5.0 запросы, в начале которых есть пробел или написан комментарий никогда не будут браться из кеша.
Кроме результатов, MySQL хранит в кеше список таблиц, выборка из которых закеширована.
Подробнее о кеше запросов, можно прочитать в источнике на [habrahabr](http://habrahabr.ru/post/41166/)
#### **От слов к делу**
Думаю, что Вам использовать, Вы уже разобрались. Дальше по тексту я описываю работу с MariaDB Galera 10, но практически все описанное, справедливо и для Percona XtraDB Cluster 5.6.
**Если мы переводим одиночную инсталяцию MySQL в кластерное исполнение:**
* Убедимся что все наши базы данных не содержат таблиц с движком MyISAM
```
SELECT table_schema, table_name FROM INFORMATION_SCHEMA.TABLES WHERE engine = 'myisam';
```
* Убедимся что у всех таблиц в наших базах данных есть первичные ключи:
```
SELECT table_catalog, table_schema, table_name, engine
FROM information_schema.tables
WHERE (table_catalog, table_schema, table_name) NOT IN
(SELECT table_catalog, table_schema, table_name
FROM information_schema.table_constraints
WHERE constraint_type = 'PRIMARY KEY')
AND table_schema NOT IN ('information_schema', 'pg_catalog');
```
**Для решения первой проблемы есть 2 пути:**
**# Вариант 1**
```
mysql имя_базы_данных -e "show table status where Engine='MyISAM';" | awk 'NR>1 {print "ALTER TABLE "$1" ENGINE = InnoDB;"}' | mysql имя_базы_данных
```
**# Вариант 2**
```
mysql имя_базы_данных -e "show table status where Engine='MyISAM';" | awk '{print $1}' | xargs -t -i pt-online-schema-change --alter-foreign-keys-method=auto --alter "ENGINE=InnoDB" --execute --statistics --set-vars="wait_timeout=10000,innodb_lock_wait_timeout=10,lock_wait_timeout=180" --progress=time,1 D=имя_базы_данных,t={}
```
Для небольших таблиц первый вариант срабатывает довольно-таки быстро. А вот с большими таблицами возникают проблемы. Так как конвертация будет выполняться долго, таблица будет заблокирована и все операции с ней станут невозможными, что непременно скажется на оказании услуг/сервисов. Для решения этой проблемы нам поможет утилита **pt-online-schema-change** из комплекта **percona-toolkit**.
**Ставится эта утилита из репозитария для CentOS**:
```
rpm -Uhv http://www.percona.com/downloads/percona-release/percona-release-0.0-1.x86_64.rpm
```
**Важно** Необходимо, чтобы у конвертируемой таблицы был или первичный (PRIMARY), или уникальный (UNIQUE) ключ, иначе выдаст ошибку, например такую:
> Cannot chunk the original table `database`.`NAMETABLE01\_NOKEY`: There is no good index and the table is oversized. at /usr/bin/pt-online-schema-change line 5442.
**Для решения второй проблемы, увы, путь только один — добавить PRIMARY или UNIQUE ключ через ALTER.**
> All tables should have a primary key (multi-column primary keys are supported). DELETE operations are unsupported on tables without a primary key. Also, rows in tables without a primary key may appear in a different order on different nodes.
Т.е. возможны выпадения нод, дедлоки и прочие проблемы. Плюс сбивается порядок строк. Это нужно чинить в первую очередь.
#### Если эти проблемы мы оставили позади, то перейдем к установке и настройке самого сервера БД.
```
cat > /etc/yum.repos.d/MariaDB.repo << EOL
[mariadb]
# MariaDB 10.0 CentOS repository list - created 2015-02-18 14:04 UTC
# http://mariadb.org/mariadb/repositories/
[mariadb]
name = MariaDB
baseurl = http://yum.mariadb.org/10.0/centos6-amd64
gpgkey=https://yum.mariadb.org/RPM-GPG-KEY-MariaDB
gpgcheck=1
EOL
```
```
yum install MariaDB-Galera-server MariaDB-client rsync galera ntp nscd
```
```
chkconfig nscd on $$ /etc/init.d/nscd start
```
**# Нужно отключить selinux, это требование разработчиков MariaDB**
```
sed -i 's/SELINUX=enforcing/SELINUX=disabled/g' /etc/selinux/config
echo 0 > /selinux/enforce
```
**# На всех нодах, должно быть правильно установленно время, это обязательно. Иначе вы столкнётесь с тем что, при SST ноды с донора, синхронизируемая нода будет просто чего-то ждать, без каких бы то ни было признаком активности.**
```
yum install ntp -y
chkconfig ntpd on
/etc/init.d/ntpd stop
ntpdate 165.193.126.229 0.ru.pool.ntp.org 1.ru.pool.ntp.org 2.ru.pool.ntp.org 3.ru.pool.ntp.org
/etc/init.d/ntpd start
```
Для настройки серверов MariaDB и кластеров Galera, я написал скрипт, он создает заготовку конфигурационного файла, индивидуально для каждого сервера.
**Хочу еще раз сказать, на выходе мы получаем заготовку, требующую последущего редактирования.**
```
#!/bin/sh
# wget --no-check-certificate -q -O - 'https://cloud.sycraft.info/index.php/s/7bf49db6da59f6d48d61abcb2c4b4791/download' | bash -x -
# fetch -o mysqld_config.sh 'https://cloud.sycraft.info/index.php/s/7bf49db6da59f6d48d61abcb2c4b4791/download'
# sh mysqld_config.sh
if [ "$(uname)" == 'Linux' ]; then
IBS=innodb_buffer_pool_size\ \=\ $((`free -m | grep Mem | awk '{print $2}'`*60/100000))G;
socket=socket=\/var\/lib\/mysql\/mysql.sock;
DB=datadir=\/var\/lib\/mysql;
conf=\/etc;
cpu=$((`cat /proc/cpuinfo | grep -c processor`*2))
else
IBS=innodb_buffer_pool_size\ \=\ $((`dmesg |grep real\ memory | awk '{print $5}' |cut -c 2- | tail -1`*60/100000))G;
conf=\/var\/db\/mysql;
cpu=$((`sysctl hw.ncpu | awk '{print $2}'`*2))
fi
mkdir -p ~/backup/mysql > /dev/null 2>&1
mkdir $conf/mysql.d > /dev/null 2>&1
mkdir $conf/mysql.d/ssl > /dev/null 2>&1
mkdir /var/log/mysql > /dev/null 2>&1
chown mysql:mysql $conf/mysql.d
chown mysql:mysql $conf/mysql.d/ssl
chown -R mysql:mysql /var/log/mysql
if [ -f $conf/my.cnf ]; then
cp $conf/my.cnf ~/backup/mysql/my.cnf.`date +%Y-%m-%d_%H-%M`
fi
if [ -f $conf/mysql.d/000-galera.cnf ]; then
cp $conf/mysql.d/000-galera.cnf ~/backup/mysql/000-galera.cnf.`date +%Y-%m-%d_%H-%M`
fi
if [ -f $conf/mysql.d/001-server.cnf ]; then
cp $conf/mysql.d/001-server.cnf ~/backup/mysql/001-server.cnf.`date +%Y-%m-%d_%H-%M`
fi
if [ -f $conf/mysql.d/002-myisam.cnf ]; then
cp $conf/mysql.d/002-myisam.cnf ~/backup/mysql/002-myisam.cnf.`date +%Y-%m-%d_%H-%M`
fi
if [ -f $conf/mysql.d/003-rep-master.cnf ]; then
cp $conf/mysql.d/003-rep-master.cnf ~/backup/mysql/003-rep-master.cnf.`date +%Y-%m-%d_%H-%M`
fi
if [ -f $conf/mysql.d/004-rep-slave.cnf ]; then
cp $conf/mysql.d/004-rep-slave.cnf ~/backup/mysql/004-rep-slave.cnf.`date +%Y-%m-%d_%H-%M`
fi
if [ -f $conf/mysql.d/005-mariadb-opt.cnf ]; then
cp $conf/mysql.d/005-mariadb-opt.cnf ~/backup/mysql/005-mariadb-opt.cnf.`date +%Y-%m-%d_%H-%M`
fi
if [ -f $conf/mysql.d/006-ssl.cnf ]; then
cp $conf/mysql.d/006-ssl.cnf ~/backup/mysql/006-ssl.cnf.`date +%Y-%m-%d_%H-%M`
fi
if [ -f $conf/mysql.d/007-handlersocket.cnf ]; then
cp $conf/mysql.d/007-handlersocket.cnf ~/backup/mysql/007-handlersocket.cnf.`date +%Y-%m-%d_%H-%M`
fi
if [ -f $conf/mysql.d/008-threadpool.cnf ]; then
cp $conf/mysql.d/008-threadpool.cnf ~/backup/mysql/008-threadpool.cnf.`date +%Y-%m-%d_%H-%M`
fi
cat > $conf/my.cnf << EOL
!includedir $conf/mysql.d/
EOL
# galera-only
cat > $conf/mysql.d/000-galera.cnf << EOL
[mysqld]
wsrep_provider = /usr/lib64/galera/libgalera_smm.so
wsrep_cluster_address = gcomm://192.168.0.30,192.168.0.40,192.168.0.41,192.168.0.74,192.168.0.75,192.168.0.76,192.168.0.161
# Node4 address
wsrep_node_address = 192.168.0.161
# Cluser name
wsrep_cluster_name = cluster
wsrep_node_name = prod-db-new-04
#wsrep_slave_threads = $cpu
innodb_autoinc_lock_mode = 2
# SST method
wsrep_sst_method = xtrabackup
wsrep_sst_auth = "sstuser:s3cretPass"
##wsrep_sst_method = rsync
wsrep_retry_autocommit = 3
wsrep_provider_options = "gcache.size=5G; repl.commit_order=1; gmcast.segment=2"
EOL
cat > $conf/mysql.d/001-server.cnf << EOL
[mysqld]
symbolic-links=0
default_storage_engine = InnoDB
innodb_file_per_table = 1
event_scheduler=on
#character-set-server = utf8
$DB
$socket
# network
connect_timeout = 600000
wait_timeout = 28800
max_connections = 600
max_allowed_packet = 512M
max_connect_errors = 10000
net_read_timeout = 600000
connect_timeout = 600000
net_write_timeout = 600000
# innodb engine settings
innodb_open_files = 512
$IBS
innodb_buffer_pool_instances = 2
innodb_file_format = barracuda
innodb_locks_unsafe_for_binlog = 1
innodb_flush_log_at_trx_commit = 2
innodb_flush_method = O_DIRECT
transaction-isolation = READ-COMMITTED
innodb-data-file-path = ibdata1:10M:autoextend
innodb-log-file-size = 256M
innodb_log_buffer_size = 8M
# performance settings
skip-name-resolve
skip-external-locking
skip-innodb_doublewrite
query_cache_size = 128M
query_cache_type = 1
query_cache_min_res_unit = 2K
join_buffer_size = 8M
read_rnd_buffer_size = 3M
table_definition_cache = 2048
table_open_cache = 2048
thread_cache_size = 128
tmp_table_size = 2048M
max_heap_table_size = 2048M
log_error = /var/log/mysql/mysql-error.log
#slow_query_log_file = /var/log/mysql/mysql-slow.log
EOL
# myisam
cat > $conf/mysql.d/002-myisam.cnf << EOL
[mysqld]
key_buffer_size = 512M
EOL
# rep-master
cat > $conf/mysql.d/003-rep-master.cnf << EOL
[mysqld]
#log-bin = /var/log/mysql/mysql-bin
# cluster
# binlog_format=ROW
# single installation
binlog_format=MIXED
server_id = 226
sync-binlog = 0
expire-logs_days = 3
max-binlog-size = 1G
log-slave-updates
EOL
# rep-slave
cat > $conf/mysql.d/004-rep-slave.cnf << EOL
[mysqld]
slave-skip-errors = 1062
log_slave_updates = 1
slave_type_conversions=ALL_NON_LOSSY
relay-log = /var/log/mysql/mysql-relay-bin
relay-log-index = /var/log/mysql/mysql-relay-bin.index
relay-log-info-file = /var/log/mysql/mysql-relay-log.info
skip-slave-start
# replicate-rewrite-db=from_name->to_name
# replicate-ignore-table=db_name.table_name
# replicate-wild-ignore-table=db_name.table_name
EOL
# mariadb-opt
cat > $conf/mysql.d/005-mariadb-opt.cnf << EOL
[mysqld]
optimizer_switch='derived_merge=off,derived_with_keys=off'
EOL
# ssl
cat > $conf/mysql.d/006-ssl.cnf << EOL
#[mysqld]
#ssl-ca = $conf/mysql.d/ssl/ca-cert.pem
#ssl-cert = $conf/mysql.d/ssl/server-cert.pem
#ssl-key = $conf/mysql.d/ssl/server-key.pem
EOL
# handlersocket
cat > $conf/mysql.d/007-handlersocket.cnf << EOL
[mysqld]
#handlersocket_address=127.0.0.1
#handlersocket_port=9998
#handlersocket_port_wr=9999
EOL
# threadpool
cat > $conf/mysql.d/008-threadpool.cnf << EOL
[mysqld]
thread_handling = pool-of-threads
thread_pool_size = $cpu
EOL
```
*Жизнь не стоит на месте и я так же как и вы, продолжаю непрерывно развиваться, последнюю версию скрипта, лучше брать сразу c ее постоянной [страницы](https://cloud.sycraft.info/index.php/s/7bf49db6da59f6d48d61abcb2c4b4791), вероятно с момента написания статьи, многое в нем уже изменилось.*
#### Пояснения к конфигу и скрипту генерации
**wsrep\_sst\_method=xtrabackup**
> Если использовать режим rsync, то в момент синхронизации ноды с донора, донор будет полностью блокирован на запись. В режиме xtrabackup же, блокировка будет длиться лишь несколько секунд, пока xtrabackup «прицепится» к базе.
>
> Если вы используете HAProxy как это описано тут [HAPRoxy для Percona или Galera на CentOS. Его настройка и мониторинг в Zabbix](http://habrahabr.ru/company/acronis/blog/198448/) то что бы работать с сервером, пока тот находится в режиме донора, нам нужно отредактировать [скрипт](https://github.com/olafz/percona-clustercheck/blob/master/clustercheck) clustercheck на нодах.
**# Заменив строку**
```
AVAILABLE_WHEN_DONOR=${3:-0}
```
**# на строку**
```
AVAILABLE_WHEN_DONOR=1
```
В таком режиме, в случае полного падения всех нод кластера, мы сможем сократить простой на синхронизацию нод до минимума.
**[transaction\_isolation=REPEATABLE-READ](http://qoo.by/CR)**
> стоит попробовать поменять на transaction-isolation = READ-COMMITTED т.е. переход на снимочное выполнение транзакций. Каждая транзакция становится своего рода независимой песочницей. Снимком данных.
>
> Это нечто похожее на уровень изоляции Oracle. Все выражения SELECT… FOR UPDATE и SELECT… LOCK IN SHARE MODE блокируют только индексные записи и не блокируют интервал перед ними. Поэтому они позволяют свободно добавлять новые записи после заблокированных. UPDATE и DELETE, которые используют уникальный индекс и уникальные условия поиска, блокируют только найденную индексную запись, и не блокируют интервал перед ней. Но в UPDATE и DELETE диапазонного типа в InnoDB должны установить блокировку следующего ключа или интервальную блокировку и блокировать добавления другими пользователями в интервал, покрытый диапазоном. Это необходимо, т.к. «фантомные строки» должны быть блокированы для успешной работы репликации и восстановления в MySQL. Согласованное чтение работает как и в Oracle: каждое согласованное чтение, даже внутри одной транзакции, устанавливает и читает свой собственный снимок.
>
> В большинстве случаев, переход дает прирост в скорости на конкурентной записи, но так же возможен эффект фантомного чтения. На своей практике я встречал лишь одно приложение, которое болело фантомностью. Т.е. это приложения использующие СУБД, нужно проверить на возможность работы в этом режиме.
**innodb\_flush\_log\_at\_trx\_commit = 2**
> Значение «1» означает, что любая завершенная транзакция будет синхронно сбрасывать лог на диск. Это вариант по умолчанию, он является самым надежным с точки зрения сохранности данных, но самым медленным по скорости работы.
>
> Значение «2» делает то же самое, только сбрасывает лог не на диск, а в кеш операционной системы (т.е. не происходит flush после каждой операции). Это значение подойдет в большинстве случаев, т.к. не выполняет дорогой операции записи после каждой транзакции. При этом лог пишется на диск с задержкой в несколько секунд, что весьма безопасно с точки зрения сохранности данных.
>
> Но у нас кластер и в случае краха, данные все равно будут переданы с донора. Главное что бы транзакция закомитилась на других нодах. Тогда данные мы получим при SST
**innodb\_buffer\_pool\_instances = 2**
> По умолчанию InnoDB использует для Buffer Pool один инстанс.
>
> При этом есть возможность выделить несколько блоков — и работает с ними MySQL в InnoDB в ряде случаев гораздо эффективнее. Это связанно с меньшими блокировками кеша при записи данных.
**innodb\_file\_format = barracuda**
> Этот формат самый «новый» и поддерживает компрессию. Это позволяет снизить нагрузку на IO (диски) путём использования сжатия. Так же как рекомендация можно использовать размер блока записи 16КБ.
**Вот пример alter’a:**
```
ALTER TABLE `t1` ENGINE=InnoDB ROW_FORMAT=COMPRESSED KEY_BLOCK_SIZE=16;
```
[Вот результаты тестирования](http://www.tocker.ca/2013/10/31/benchmarking-innodb-page-compression-performance.html) скорости и размера данных при сжатии.
**Но есть минусы сжатия**. На сжатых таблицах ALTER-ы будут происходить значительно дольше, как известно ALTER, как и любой DDL, блокирует таблицу и вместе с ней весь кластер. ALTER — это не транзакционная инструкция, а значит не реплицируются ROW-бинарными diff-ами а передаются в виде запосов. И пока этот запрос не исполнится на всех нодах кластера, все коммиты будут заморожены.
Т.е. сжатие имеет смысл делать либо на больших таблицах, где не планируются DDL в принципе, либо на одиночных инстансах mysql.
**innodb\_flush\_method = O\_DIRECT**
> Сброс данных минуя дисковый кеш. Это нужно для исключения двойной буферизации данных в кеше innodb\_buffer\_pool и кеше файловой системы. Позволит более рационально использовать оперативную память.
Стоит добавить [важный](http://www.percona.com/blog/2006/08/04/innodb-double-write/) с точки зрения производительности параметр **skip-innodb\_doublewrite**
> Even though double write requires each page written twice its overhead is far less than double. Write to double write buffer is sequential so it is pretty cheap. It also allows Innodb to save on fsync()s – instead of calling fsync() for each page write Innodb submits multiple page writes and calls fsync() which allows Operating System to optimize in which order writes are executed and use multiple devices in parallel. This optimization could be used without doublewrite though, it was just implemented at the same time. So in general I would expect no more than 5-10% performance loss due to use of doublewrite.
**tmp\_table\_size = 2048M
max\_heap\_table\_size = 2048M**
> Очень интересные параметры, их значения нужно выжать на максимум. Это позволит сократить количество создаваемых на диске временных таблиц. Как правило, именно создаение временных таблиц на диске, занимает большее количество времени на сортировках, группировках и других сложных select.
**optimizer\_switch='derived\_merge=off,derived\_with\_keys=off'**
> Бывают проблемы с совместимостью приложения с базой, после перехода на percona 5.6 и galera 10. Наиболее значительные из них стоит сразу предупредить параметром
**thread\_handling = pool-of-threads
thread\_pool\_size = количество\_ядер**
> Так же, стоит использовать [thread\_pool](http://www.percona.com/blog/2014/01/23/percona-server-improve-scalability-percona-thread-pool/)
**wsrep\_retry\_autocommit = 3**
**Важно!** Если в базе дедлок, коммиты будут ретраиться, т.е. нода не будет выпадать из кластера при первом же чихе, а будет дальше работать и мы не теряем коммит.
**wsrep\_provider\_options = «gcache.size=5G; repl.commit\_order=1; gmcast.segment=2»**
[Вот](http://www.percona.com/blog/2013/11/22/new-wsrep_provider_options-galera-3-x-percona-xtradb-cluster-5-6/) подробное описание, эти параметры я обычно ставлю по умолчанию всегда.
Параметр **wsrep\_replicate\_myisam=1** это почти 100% гарантия смерти кластера если там появится хоть одна боевая myisam таблица.
> Данная фича до сих пор экспериментальная и ее включение добавляет к ROW (на базе бинарных diff снимков) репликации еще и statement, те как и при репликации DDL команд. Это значит постоянные конфликты, блокировки и развал кластера после любого дедока myisam таблицы.
**Если у вас возникнут вопросы, трудности или потребуется совет:
Мои контакты в [профиле](http://habrahabr.ru/users/sycraft/)** | https://habr.com/ru/post/253869/ | null | ru | null |
# Устанавливаем бесплатный SSL–сертификат StartSSL на облачный VPS от Infobox
В этой статье мы рассмотрим, как заказать бесплатный SSL–сертификат и установить его на [облачный VPS от Infobox](http://infobox.ru/vps/cloud). Базовые SSL–сертификаты бесплатно выдает центр сертификации [StartCom](https://www.startssl.com/?lang=ru).
Бесплатные сертификаты StartSSL класса 1 служат для подтверждения доменных имен и адресов электронной почты. Проверки заказчиков, как правило, производятся автоматически и требуют минимального участия со стороны сотрудников StartCom. В процессе проверки подтверждается то, что подписчик является владельцем домена и действующего ящика электронной почты.
Бесплатные сертификаты предназначены для веб-сайтов, которым необходима защита секретности личных данных и предотвращение возможности прослушивания интернет-соединений. Информация, представленная в сертификатах этого вида, кроме имени домена и адреса электронной почты, не подтверждена. Если вам необходима сертификация [более высокого уровня](https://helpdesk.infobox.ru/Knowledgebase/Article/View/569/42/) — можно заказать SSL сертификат в [панели управления](https://panel.infobox.ru) Infobox на главной странице в блоке «Мои услуги» -> «Заказать новую услугу». Доступ к панели управления предоставляется при заказе любой услуги, например [VPS](http://infobox.ru/vps/linux) или [облачных VPS](http://infobox.ru/vps/cloud).
Для обеспечения секретности передаваемых данных простых сайтов сертификаты StartCom подходят неплохо.
*Бесплатные сертификаты от StartCom на самом деле не совсем бесплатные. Если потребуется отзыв сертификата — эта процедура стоит $24 у StartCom.*
#### **Заказ бесплатного SSL–сертификата**
Откройте [страницу заказа](https://www.startssl.com/?app=11&action=regform) бесплатного сертификата SSL. Заполните информацию о вас (данные должны быть реальными, это очень важно).
На следующем шаге от вас потребуется код подтверждения, отправленный на указанную электронную почту.
Введите код и нажмите «Continue»
После этого необходимо дождаться подтверждания регистрации от StartCom (может занимать до 6 часов, но обычно ссылка для доступа и код подтверждения приходит гораздо быстрее). После получения письма введите код из него по ссылке, указанной в письме. Далее выберите длинну сертификата (лучше выбирать максимальную).
После этого будет сгенерирован сертификат для доступа к сертифицирующему центру StartCom. Сохраните его в безопасном месте и установите в систему, выполнив по нему двойной клик мышью и нажав «Install».
Теперь у вас есть доступ к сертифицирующему центру. На следующем шаге введите имя домена, для которого хотите получить сертификат.
Для подтверждения домена необходимо создать на нем один из трех адресов:
* postmaster@domain
* hostmaster@domain
* webmaster@domain
Если у вас еще не подключена почта для домена, можно привязать домен к бесплатной [Яндекс.Почте](http://pdd.yandex.ru) или воспользоваться [бизнес-почтой «Офис 24»](http://office24.ru/)
После создания почтового ящика на домене выберите его у StartCom и подтвердите принадлежность домена вам.
После подтверждения владения доменом вы можете сгенерировать секретный ключ, как показано на скриншоте ниже:
**Рекомендуется пропустить этот шаг и сгенерировать CSR на вашем облачном VPS. Так секретный ключ не окажется у StartCom.**
Для генерации CSR подключитесь к виртуальному серверу [по SSH](https://helpdesk.infobox.ru/Knowledgebase/Article/View/335/)(подробнее в следующем разделе) и выполните команду:
```
openssl req -new -newkey rsa:4096 -nodes -keyout /etc/ssl/private.key -out /etc/ssl/domain.csr
```
В FQDN укажите ваш домен. E–mail адрес обязательно должен быть в этом домене, например webmaster@domain.com.
После генерации выведите на экран консоли содержимое файла domain.csr:
```
cat /etc/ssl/domain.csr
```
и вставьте в поле мастера выдачи сертификатов, который появится после нажатия на Skip окна генерации сертификатов.
Согласитесь с предложенным именем домена.
На следующем шаге добавьте поддомен www к сертификату.
Завершите процесс получения ssl.crt и сохраните его.
Вам понадобится корневой и промежуточный сертификаты StartCom. Для их получения перейдите в раздел Toolbox -> StartCom CA Certificates.
Сохраните файлы по ссылке Class 1 Intermediate Server CA (sub.class1.server.ca.pem) и StartCom Root CA (ca.pem).
В итоге у вас будут сохранены на локальном компьютере следующие полезные файлы:
* ca.pem
* sub.class1.server.ca.pem
* ssl.crt
На сервере в папке /etc/ssl/:
* private.key
#### **Копируем файлы на сервер**
Создайте сервер из шаблона Ubuntu 14.04 lamp в [облаке](http://infobox.ru/vps/cloud). Процесс создания сервера был [рассмотрен в статье](https://infoboxcloud.ru/community/blog/iaas/267.html) ранее.
Необходимо скопировать **ca.pem, sub.class1.server.ca.pem и ssl.crt** в папку **/etc/ssl** (если ее нет — создать).
Это можно сделать например через Filezilla (установка клиента рассмотрена также в [статье](https://infoboxcloud.ru/community/blog/iaas/267.html)). Однако способ подключения будет отличаться, так как нужен доступ не только к папке сайта, но и ко всему серверу.
Добавьте новое SFTP подключение, как показано на скриншоте ниже. Используйте логин и пароль от сервера, которые пришли на вашу электронную почту после создания сервера, а также внешний ip–адрес сервера.
При подключении подтвердите, что вы подключаетесь к известному вам серверу, нажав OK.
Подключение будет успешно установлено.
Перейдите в папку "/etc/ssl" и скопируйте туда файлы ca.pem, sub.class1.server.ca.pem и ssl.crt.
Теперь подключитесь к серверу [по SSH](https://helpdesk.infobox.ru/Knowledgebase/Article/View/335/).
#### **Включаем SSL в NGINX**
В шаблоне LAMP настраивать SSL нужно на реверс-прокси NGINX.
*Если ранее при генерации CSR вы установили пароль, расшифруйте приватный ключ командой:
```
openssl rsa -in /etc/ssl/ssl.key -out /etc/ssl/private.key
```*
Объедините корневой и промежуточный сертификаты командой:
```
cat /etc/ssl/sub.class1.server.ca.pem >> /etc/ssl/cau.pem
```
Добавьте к объединению ваш сертификат
```
cat /etc/ssl/ssl.crt /etc/ssl/cau.pem >> /etc/ssl/group.crt
```
Откройте результат в nano:
```
nano /etc/ssl/group.crt
```
Сохраните изменения (Ctrl+X, Y, Enter).
Перенесите начало каждого нового сертификата на новую строчку после окончания предыдущего сертификата и сохраните изменения.
Теперь установите права для доступа к private.key:
```
chmod 600 /etc/ssl/private.key
```
Отредактируйте файл конфигурации nginx:
```
nano /etc/nginx/sites-enabled/default
```
Внесите изменения, как показано на скриншоте ниже (вместо le-vert.ru используйте ваш домен):
Перезапустите NGINX.
```
service nginx restart
```
Если вы попробуете зайти на сайт по ip–адресу по протоколу HTTPS, то вы увидите предупреждение о том, что сертификат небезопасен.
Для безопасного соединения заходите на сайт по имени домена.
Для этого в DNS-записи А для домена и поддомена www укажите ip–адрес сайта и дождитесь обновления DNS. Либо для тестирования пропишите соответствие ip–адреса сервера и домена в файле hosts вашей ОС.
Единственное небезопасное что осталось — картинкa на странице загружается по http. Для того, чтобы сайт был доверенным, загружайте картинки по https.
Успешного использования [Infobox](http://infobox.ru/vps/cloud)! | https://habr.com/ru/post/256283/ | null | ru | null |
# MrRobotQR сканируем QR-коды из поисковых систем в поисках приватных ключей Биткоин Кошельков
Всем нам известна фраза: *"Все что попадает в интернет, остается в нем навсегда и становится общедоступным".*
#### Вплоть до скрытого контента
В `2021 году` пандемия вернула популярность `QR-кодов`. Впервые `QR-коды` были использованы на производстве в `1994 году` дочерняя компания `Toyota` в Японии ввела их на заводе по сборке для контроля выпускаемых автомобилей и деталей к ним. В отличие от штрих-кода `QR-код` содержит больше информации, что и подтолкнуло производителя к введению инновации. Технология начала распространяться в основном в азиатских странах, а в `2003 году` китайская компания [Inspiry](https://www.inspiry.com.cn/) разработала специальный механизм считывания `QR-кодов`, который позволил это делать быстро, что подогрело популярность. Однако широкое распространение пришлось уже на период массового использования *планшетов* и *смартфонов*, когда считывание стало доступно через камеру носимого устройства.
Устройства от китайской компании InspiryС одной стороны QR-коды предоставляют все удобства в платежах `BTC`, так как можно не тратить по полчаса на оформление перевода. Достаточно навести смартфон на `QR-код` и платежка со всеми заполненными полями сформируется сама, останется только нажать кнопку с подтверждением оплаты.
> `Переводы`, `оплаты`, `QR-коды` просто незаменимая вещь и самое важное в том что все это *экономит наше время*.
>
>
#### Нужно помнить ещё одну важную вещь
`Googlebot`, `Bingbot`, `Baidubot` работают `24/7` и в любой момент могут сохранить приватные данные в своих гигантских серверах.
На поиски скрытого контента из глубин поисковых систем подключаются совершено противоположенные поисковым ботам герои в черном худи из известного сериала Мистер Робот `(Mr. Robot)` .
> `«MrRobotQR»` - *это скрипт с открытым исходным кодом который автоматизирует процесс от ввода ключевого слова поиска до вывода приватного ключа Биткоин кошелька.*
>
>
#### Для запуска скрипта потребует Python 3 и Bash
*Bash*-скрипт: [mrrobotqr.sh](https://github.com/demining/CryptoDeepTools/blob/main/10MrRobotQR/mrrobotqr.sh) автоматизирует следующие шаги:
Запуск *Python*-скрипта: [qrcrawler.p](https://github.com/demining/CryptoDeepTools/blob/main/10MrRobotQR/qrcrawler.py)[y](http://qrcrawler.py) с указанными *ключевыми словами* для поиска и сканирования *изображений* в `Google`, `Bing` и `Baidu`.
Все найденные изображений будут загружены в папку `qrbooty` с подпапками для каждой поисковой системы. Затем скрипт переименовывает и перемещает файлы из подпапок в папку `qrbooty` с уникальными именами.
Далее идёт запуск *Python*-скрипта: [qr2key.py](https://github.com/demining/CryptoDeepTools/blob/main/10MrRobotQR/qr2key.py) для сканирования загруженных *изображений* в папке `qrbooty` на наличие `QR-кодов` и проверяет, содержат ли они *приватные ключи* Биткоин кошелька. Все приватные ключи будут сохранены в текстовый файл: `keylist.txt`.
После повторной обработки скрипт *удаляет дубликаты* в `keylist.txt` и выводит *уникальные ключ* и в новый файл: `keylist_unique.txt` , где будут уже содержаться все *уникальные приватные ключи* Биткоин кошелька.
Установка и запуск
------------------
Откроем [**[TerminalGoogleColab]**](https://github.com/demining/TerminalGoogleColab).
Воспользуемся репозиторием [**«10MrRobotQR**»](https://github.com/demining/CryptoDeepTools/tree/main/10MrRobotQR).
```
git clone https://github.com/demining/CryptoDeepTools.git
cd CryptoDeepTools/10MrRobotQR/
ls
```
### Установим программный пакет ZBar для считывания штрих-кодов
```
sudo apt install python3-dev python3-setuptools python3-pip libzbar0 libzbar-dev
```
---
### Установим все нужные нам пакеты, модули и библиотеки
```
cat requirements.txt
```
```
pip3 install -r requirements.txt
```
---
Права доступа к файлам:
-----------------------
```
chmod +x mrrobotqr.sh
chmod +x qr2key.py
chmod +x qrcrawler.py
```
> `"bitcoin qr"` - *ключевое слово для поисковых систем*
>
>
Запуск Bash-скрипта:
--------------------
```
./mrrobotqr.sh "bitcoin qr"
```
Открываем и смотрим все сохраненные уникальные ключи в файле: `keylist_unique.txt`
```
cat keylist_unique.txt
```
---
История поисков с положительным балансом монет BTC
--------------------------------------------------
Откроем [bitaddress](https://cryptodeep.ru/bitaddress.html) и проверим:
```
Private Key WIF: L4vNZ86Pp6mkEPSPz9EcELK8cp1BxP3LWjxh7QvDanuMQBUJT9cG
Bitcoin Address: 1JhCAfiAbwJSa65c2EDCfC9fbEwyzZZb25
Total balance: 0.01393000 BTC
```
---
```
Private Key WIF: L2HcNb8wPCQ2gpL4oT5Mn6cvKqfAFjCqK3qWquak9BvYasbgWxxF
Bitcoin Address: 18cif9QYoSPSrmv9MN157mUejyNMr5wYVx
Total balance: 0.01313000 BTC
```
---
```
Private Key WIF: KwFs9DSx3qQbagnRiZ2niczs5QteL1bE13mBdXFGAW1He7BxQ9qz
Bitcoin Address: 1KyUqCo3pbBHvCp7ZcBvUSEaTLBocUAoU3
Total balance: 0.03611000 BTC
```
---
```
Private Key WIF: L5CGhW2yDnq3pGQdKm3ocM3AE32EekoKkKN6DvUqstziayr1R79V
Bitcoin Address: 1AuRL68EyKTFAafj98GR2oAi7b9abNr3ja
Total balance: 0.03602000 BTC
```
---
```
Private Key WIF: L3sxBKQ8HbFAv2vshfsL6RTEX8zP9CLDzw9BCh6hd5VTiihoAX5n
Bitcoin Address: 1H957muSj2Sn23Mnym5DEoYquQqviqc7Ch
Total balance: 0.03628000 BTC
```
---
```
Private Key WIF: KzpPtHkQbZj32Pxtoo31bPZtbVbVV5DASdmaFWawgrYXBxhfNoLj
Bitcoin Address: 1PCLwUTMj6z7up1mDGbEbMVhaQif9xBB5M
Total balance: 0.03632000 BTC
```
---
```
Private Key WIF: L1DoUbneUoNAMqFHeGyerzXyxwbzYWB1mD2JL8sn855EgZKJxC5d
Bitcoin Address: 1N5rmtTVvtTkVPB8xJNPx3bbaS7kZX2kX
Total balance: 0.01466000 BTC
```
---
```
Private Key WIF: KzcTCCpwMFu3yS5EBczmD9bv4GSD42vCoicJzCrZdm4eyYRvBiGE
Bitcoin Address: 1WeWVwSsUDgtMagerivywQzmBbeL2ETVJ
Total balance: 0.03677000 BTC
```
---
```
Private Key WIF: Kydoae8uQDUjxVWqqgqzoTQtMYkA6x1MGiPTx76AuTzyxdBTAYHc
Bitcoin Address: 1Mz7STzHf3JBuG4fvXuiz1brGRXF2C4R9R
Total balance: 0.03498000 BTC
```
---
```
Private Key WIF: KzWA3G6wyAdWSpACmJXAec76xhFxMPhnzwKLK3pk1gxm4RencWmo
Bitcoin Address: 1HnBT3t4AKBP54UDTNGJB39DAv7caf7HP1
Total balance: 0.01601000 BTC
```
---
Данный видеоматериал создан для портала [**CRYPTO DEEP TECH**](https://cryptodeep.ru/) для обеспечения финансовой безопасности данных и криптографии на эллиптических кривых `secp256k1` против слабых подписей `ECDSA` в криптовалюте `BITCOIN`
[**Исходный код**](https://github.com/demining/CryptoDeepTools/tree/main/10MrRobotQR)
[**Telegram**](https://t.me/cryptodeeptech)**:**[**https://t.me/cryptodeeptech**](https://t.me/cryptodeeptech)
[**Видеоматериал: https://youtu.be/bNMg2iJhMpg**](https://youtu.be/bNMg2iJhMpg)
[**Источник: https://cryptodeep.ru/mr-robot-qr**](https://cryptodeep.ru/mr-robot-qr)
--- | https://habr.com/ru/post/684362/ | null | ru | null |
# Делаем станцию мониторинга загрязнённости воздуха в домашних условиях
В этой статье я расскажу о том, как собрать датчик загрязнённости воздуха в домашних условиях и зачем это нужно.
В последнее время всё больше людей озадачивается проблемой загрязнённости воздуха. Одним из видов загрязнения воздуха является взвешенные частицы размером до 10 мкм, которые не отфильтровываются носоглоткой и проникают глубоко в лёгкие. Такие частицы, обозначаемые PM10, PM2.5 и PM0.1 (по их размеру в микрометрах), представляют большую опасность для здоровья человека, вызывая астму, рак лёгких, всевозможные респираторные и сердечно-сосудистые заболевания, врождённые дефекты у новорождённых и даже преждевременную смерть.
По [информации ВОЗ](https://www.who.int/ru/news-room/fact-sheets/detail/ambient-(outdoor)-air-quality-and-health), в 2016 году около 4,2 миллиона смертей было вызвано влиянием частиц PM2.5. Кроме промышленности, значительным источником мелко- и крупнодисперсных частиц является автотранспорт (в частности, автопокрышки).
Стандарты Европейского союза определяют индекс качества воздуха в зависимости от концентрации взвешенных частиц:
| [Европейский индекс качества воздуха](https://www.eea.europa.eu/themes/air/air-quality-index) | Хорошее | Удовлетворительное | Среднее | Плохое | Очень плохое | Чрезвычайно плохое |
| --- | --- | --- | --- | --- | --- | --- |
| Размер до 2,5 мкм (PM2.5) | 0–10 мкг/м³ | 10–20 мкг/м³ | 20–25 мкг/м³ | 25–50 мкг/м³ | 50–75 мкг/м³ | 75–800 мкг/м³ |
| Размер до 10 мкм (PM10) | 0–20 мкг/м³ | 20–40 мкг/м³ | 40–50 мкг/м³ | 50–100 мкг/м³ | 100–150 мкг/м³ | 150–1200 мкг/м³ |
Общественный мониторинг
-----------------------
Во многих европейских странах помимо мониторинга качества воздуха, осуществляемого государственными организациями, осуществляется и общественный мониторинг, производимый независимыми организациями и просто жителями городов и деревень. Один из таких проектов, LuftDaten, основан [группой сотрудников Штутгартской высшей технической школы](https://luftdaten.info/). В рамках этого проекта был разработан вебсайт для сбора данных, а также простые в сборе датчики, которые может разместить у себя дома каждый желающий. Как сайт, так и прошивка устройства являются свободным ПО.
Карта чистоты воздуха от LuftDaten. Картографические данные: © Участники OpenStreetMapКак видно из [карты на их сайте](https://maps.sensor.community/), датчики установлены уже во всех странах Европы, хотя больше всего их, конечно же, в Германии.
Кроме LuftDaten, существуют и другие похожие проекты: OpenSenseMap (тоже немецкий), а также [AirCMS](https://aircms.online/) (из Челябинска). Прошивка для датчиков от Luftdaten позволяет отправлять данные сразу в несколько проектов, а также на произвольные web API.
Конечно же, точность данных, полученных таким способом, ниже, чем у дорогих станций мониторинга, используемых государственными организациями, но у общественной сети есть потенциал лучше покрыть территорию более дешёвыми станциями, получая хоть какое-то представление о ситуации в местах, где нет официальных станций мониторинга. Кроме того, существует возможность математически «привязать» и откалибровать менее точные данные с помощью данных, полученных от более точных станций.
Подробнее о датчике
-------------------
Вариантов датчика существует несколько как в плане конкретных комплектующих, так и сборки как таковой. «Классический» вариант, предлагаемый LuftDaten — платка с ESP8266 (NodeMCU) с сенсором Nova SDS011 в пластиковой трубе:
Датчик AirRohrГотовый установленный датчик выглядит примерно так, как на фотографии в начале статьи.
Конечно же, использовать трубу не обязательно, корпус может быть любым, но способным выдержать погодные условия на улице 365 дней в году:
Мой датчик, установленный на подоконникеАльтернативой предлагаемой конструкции является набор AirRohr-Kit от Эрика Несстрёма, который разработал модели для 3D-принтера и печатную плату, предназначенную для установки в электромонтажную коробку:
Схема сборки AirRohr-KitНеобходимые компоненты
----------------------
* Плата с микроконтроллером ESP8266, например Wemos D1, NodeMCU
* Датчик пыли SDS011 (мне обошёлся в € 14 на AliExpress)
* Датчик температуры, влажности, атмосферного давления: BME280, BMP280, DHT22
* Куча проводов
* Подходящий корпус
* Пластиковая трубка с внутренним диаметром 6 мм
* Плоский кабель USB A—Micro-B (рекомендуемая длина около 2 м)
* Источник питания 5 В (мин. 500 мА) с разъёмом USB (например, зарядное устройство от телефона)
* Может пригодиться паяльник
Пару слов о датчиках температуры и прочего. Первоначально проектом поддерживались датчики DHT22, измеряющие температуру и влажность, параметры, которые полезно знать при анализе собранных данных. DHT22 (а также его более ограниченный собрат DHT11) предоставляют разрешение 1°C (кроме этого, DHT11 не может измерять температуры ниже 0°C). Чтобы улучшить качество данных, можно использовать альтернативу, BME280 от фирмы Bosch. BME280 даёт более точные измерения температуры с разрешением 0.01°C, а также измеряет атмосферное давление, поэтому LuftDaten рекомендуют использовать именно его. Разница в качестве измерений хорошо видна на этом графике из [статьи](https://randomnerdtutorials.com/dht11-vs-dht22-vs-lm35-vs-ds18b20-vs-bme280-vs-bmp180/) от *Random Nerd Tutorials*:
Сравнение датчиков температурыК сожалению, в моём местном магазине радиодеталей BME280 не оказалось, потому мне пришлось купить BMP280, вариант без измерения влажности, и DHT22, чтобы влажность всё же измерить. Надо сказать, что DHT22 в таких магазинах продаётся в двух вариантах: датчик сам по себе либо на плате с pull-up-резистором:
Модуль DHT22 с pull-up-резисторомВ моём магазине цена была одинаковая, но я по ошибке заказал именно эту версию. Как оказалось, их не было на складе, ждать пришлось бы долго, но на складе был и датчик без платы за ту же цену. Проверка исходного кода прошивки показала, что в ней используется встроенный pull-up микропроцессора, так что внешний резистор, на платке или нет, не нужен (но с десяток резисторов я с перепугу всё же купил, т. к. проверить их необходимость в магазине не было возможности).
Прошивка
--------
Рекомендуется прошить процессор перед сборкой. Сделать можно это совсем вручную с помощью утилиты `esptool`, но лучше это сделать специальным скриптом. Можно скачать сборки под разные операционные системы на [сайте проекта](https://firmware.sensor.community/airrohr/flashing-tool/), либо же поставить из исходников с [GitHub](https://github.com/opendata-stuttgart/airrohr-firmware-flasher).
После прошивки и перезапуска процессора должна появиться новая Wi-Fi сеть, как правило, начинающаяся на `airRohr` (в зависимости от языка и версии прошивки). Подключившись к этой сети, надо зайти на <http://192.168.4.1/> и настроить подключение к домашней Wi-Fi сети. Надо сказать, что на этом шагу я на какое-то время зациклился: датчик упорно не хотел подключаться к сети, создавая свою собственную. Я подключил отладку через USB-serial (если будете пробовать, скорость нужно задать 9600 бод, эта скорость отличается от скорости загрузчика прошивки), где было видно, что датчик к сети подключается, но ошибок нет. Я уже было отчаялся, как вдруг сеть `airRohr` пропала и датчик появился в домашней сети: оказывается, в настройках есть параметр *Duration router mode*, в течение которого датчик будет в некоторых случаях держать собственную сеть, чтобы дать возможность поменять настройки.
Сборка
------
Как я уже упоминал выше, можно использовать как NodeMCU, как и более компактную плату Wemos D1. Функционально они идентичны, но NodeMCU несколько крупнее и имеет больше выводов. В моём распоряжении было несколько плат Wemos D1, так что я использовал именно их, но именно это решение привело к некоторым усложнениям в процессе сборки.
Схема подключения SDS011 и BME280Как видно из схемы, датчик SDS011 подключается через UART, в то время как BME280 — через I²C. В моём случае вместо BME280 был BMP280, подключаемый на те же контакты, а также ещё и DHT22, который подключается на D7 (см. схему подключения). Всё бы хорошо, но у Wemos D1, в отличие от NodeMCU, лишь один контакт 3V3 и всего один GND! Пришлось паять разветвитель GND и удлинитель 3V3.
В итоге мой Франкенштейнов монстр выглядел примерно так:
Вся электроника в сбореК процессорной платке я прикрепил изолентой кусок пористого пенопласта, чтобы в случае попадения влаги внутрь корпуса, хотя бы часть её задержать. Всё устройство было помещено в ведёрко от йогурта. Важно в корпусе сделать не только отверстие для гибкой трубки, ведущей к SDS011, но и дополнительные отверстия, обеспечивающие циркуляцию воздуха, в том числе и для того, чтобы показания датчиков температуры, влажности и давления имели какой-то смысл.
Плохо себя зарекомендовала упаковка от маргарина: после чуть менее, чем года на улице, коробочка начала рассыпаться, в конце концов во время ливня вода попала внутрь и каким-то образом повредила датчик пыли:
Рама не совсем хариКак видно из фотографий выше, свои датчики я размещаю на подоконнике (например, приклеив двусторонним скотчем). С размещением я советую внимательно подумать, приняв к вниманию как метеоусловия (ветер, солнце), так и наличие источников загрязнения. Например, один из моих датчиков находится на солнечной стороне, потому показания температуры у него очень часто завышены. Расстояние до источников загрязнения может влиять на показания, занижая и завышая их, либо же вообще делая их бесполезными. Например, возле нашего дома находится [крупная стройка](https://imhd.sk/ba/gallery/5107/Construction-of-new-bus-station-Mlynsk%C3%A9-nivy), которая уже продолжается три года, и данные насчёт того, сколько пыли она производит, весьма интересны. С другой стороны, концентрация пыли прямо на стройке несколько другая, чем возле домов, где живут люди, поэтому если датчик размещён слишком близко, польза от данных будет сомнительная. Также необходимо учитывать расстояние от дороги (покрышки автомобилей также создают массы взвешенных частиц).
После установки и проверки датчика его можно подключить к API разных проектов. Данные со своих датчиков я посылкаю на [sensor.community](https://sensor.community) (LuftDaten), агрегатор [Madavi](https://api-rrd.madavi.de/grafana/d/000000004/single-sensor-view-for-map?orgId=1), [OpenSenseMap](https://opensensemap.org), [AirCMS](https://aircms.online/) и ещё пару проектов:
Настройки API датчикаВот так выглядит карта PM2.5 от LuftDaten (два датчика на ней мои):
Словакия на карте LuftDaten. Картографические данные: © Участники OpenStreetMapНа AirCMS датчиков в наших краях гораздо меньше:
Словакия на AirCMS. Картографические данные: © ЯндексСсылки по теме
--------------
* [Stuttgarter OK Lab und Hochschule testen Prototyp: Bürger können selber Lärm messen - Stuttgart - Stuttgarter Zeitung](https://www.stuttgarter-zeitung.de/inhalt.ok-lab-und-hochschule-testen-prototyp-buerger-koennen-selber-laerm-messen.8d3b8e53-c502-4732-acf3-f47169adb5fe.html)
* [Sensor Community — Build your own particulate matter sensor](https://sensor.community/en/sensors/airrohr/)
* [AirRohr-kit: A complete kit for building a Air Quality meter for the Luftdaten.info project](https://github.com/opendata-stuttgart/Airrohr-kit)
* [дыши:москва](https://breathe.moscow/)
* [Покупка, сборка и настройка станции мониторинга воздуха](https://docs.google.com/document/d/1cDL0KtBHc0Q2Dq_zfSVBFS6UNHIDVBUb3gaUc5YoP2w/view)
* [How to assemble PM Station SDS011 BME280 of the Luftdaten Info Project - YouTube](https://www.youtube.com/watch?v=83nSjiInZ3U) | https://habr.com/ru/post/525140/ | null | ru | null |
# От идеи к разработке: что нужно знать о создании стратегий для торговли на бирже. Часть III
[](https://habrahabr.ru/company/itinvest/blog/281148/)
На Хабре и в [аналитическом разделе нашего сайта](http://www.itinvest.ru/analytics/) мы много пишем о тенденциях финансового рынка и продолжаем публикацию серии материалов, посвященных вопросам создания стратегий для торговли на бирже, основанную на статьях автора блога Financial Hacker. В предыдущих материалах, раскрывающих главные тезисы цикла статей автора блога Financial Hacker, мы поговорили об [использовании неэффективностей](https://habrahabr.ru/company/itinvest/blog/279321/) рынка на примере истории с ценовым ограничением для швейцарского франка и рассмотрели важные факторы, которые нужно учитывать при [создании стратегий](https://habrahabr.ru/company/itinvest/blog/280059/) для торговли на бирже.
В этот раз [речь пойдет](http://www.financial-hacker.com/build-better-strategies-part-3-the-development-process/) об общих принципах разработки модель-ориентированных трейдинговых систем.
#### Разработка «идеальной» стратегии
Как и во многих других случаях, когда дело касается разработки стратегий для торговли на бирже, есть два пути: идеальный и реальный. Для начала рассмотрим идеальный процесс разработки стратегии.
##### Шаг 1. Выбор модели
Для начала трейдеру следует выбрать одну из [описанных](https://habrahabr.ru/company/itinvest/blog/280059/) ранее неэффективностей рынка или обнаружить новую. Вполне возможно, что какие-то идеи появятся при анализе ценовой кривой, когда что-либо подозрительное будет отвечать определенной логике рынка. Годится и противоположный вариант – от теории поведенческого паттерна к его проверке на реальных данных. Правда, все закономерности и неэффективности, скорее всего, уже открыты и изучены другими участниками рынка за много лет.
Определившись с моделью, необходимо будет выбрать ценовую аномалию, которая ей соответствует. Затем, описать ее с помощью количественной формулы или, в крайнем случае, посредством качественного критерия. В качестве примера можно использовать циклическую модель из предыдущей статьи:
В нашем случае (Ci) – продолжительность, (Di) — фаза и (ai) – амплитуда. Один из самых успешных фондов в истории — Renaissance Medallion — уверяет, что смог добиться хороших результатов, используя модель циклов вместе со скрытой марковской моделью.
##### Шаг. 2. Поиски
Нужно также убедиться, что выбранная аномалия действительно проявляет себя в ценовой кривой активов, которыми трейдер собирается торговать. Проверить это можно с помощью исторических данных — D1, M1 и тиковые значения, показывающие распределение аномалии по временной оси. Весь вопрос, насколько глубоко в прошлое нужно копать? Ответ: насколько это возможно. Пока не выяснятся условия возникновения аномалии. Затем придется написать скрипт, который будет находить и демонстрировать аномалию на ценовой кривой. В нашем примере это будет частотный спектр для пары евро/доллар:
Необходимо выяснить, как меняется спектр за условные промежутки времени – месяцы и годы, а затем сравнить его со спектром случайных данных (в некоторых языках программирования, вроде Zorro, есть специальные функции для рандомизации кривых). Если никаких признаков аномалии и отличий от случайного распределения не обнаружено, трейдеру придется усовершенствовать метод обнаружения аномалии. И если ничего не выйдет – то вернуться к шагу 1.
##### Шаг 3. Алгоритм
Следующий шаг подразумевает написание алгоритма, который будет генерировать торговые сигналы на открытие и закрытие позиций, следуя выбранной аномалии. В обычной ситуации неэффективность рынка слабо влияет на ценовую кривую. Поэтому алгоритм должен быть настроен достаточно тонко, чтобы отделять проявление аномалии от случайного шума. В то же самое время он должен быть настолько простым, насколько это вообще возможно, и основываться на минимальном числе свободных параметров. В нашем варианте скрипт меняет позицию на каждой впадине и пике синусоиды, которая идет поверх доминирующего цикла:
```
function run()
{
vars Price = series(price());
var Phase = DominantPhase(Price,10);
vars Signal = series(sin(Phase+PI/4));
if(valley(Signal))
reverseLong(1);
else if(peak(Signal))
reverseShort(1);
}
```
Это ядро системы. Теперь наступает время для бэктестинга. Точность исполнения задачи в данном случае не так важна, нужно просто определить границы действия алгоритма. Сможет ли он осуществить серию выгодных сделок в конкретных рыночных ситуациях? Если нет, остается два варианта: переписать или создать заново, используя другой метод. На данном этапе не нужно пичкать алгоритм трейлинг-стопами и прочей начинкой. Они исказят результат и создадут иллюзию выгоды на пустом месте. Алгоритм должен научиться просто получать прибыль хотя бы в случае закрытия позиций по времени.
На данном этапе также нужно определиться с данными для бэктеста. Для рабочего теста достаточно M1 и тиковых котировок. Суточные данные не годятся. Объем данных зависит от продолжительности аномалии (которая была определена на втором этапе) и ее природы. Обычно, чем длиннее период, тем точнее тест. Не имеет смысла закапываться глубже, чем на 10 лет. По крайней мере, если речь идет о реально существующем поведением рынка — за десяток лет рынок меняется критически. Устаревшие данные дадут неверный результат.
##### Шаг 4. Фильтр
Ни одна неэффективность не длится вечно. Любой рынок проходит через периоды произвольного поведения котировок. Поэтому для каждой успешной трейдинговой системы критично иметь фильтр, который бы определял наличие или отсутствие неэффективности. Фильтр также важен, как и сигнал, если не еще важнее. Но, по разным причинам, о нем часто забывают. Ниже пример скрипта, устанавливающего фильтр для торговой системы:
```
function run()
{
vars Price = series(price());
var Phase = DominantPhase(Price,10);
vars Signal = series(sin(Phase+PI/4));
vars Dominant = series(BandPass(Price,rDominantPeriod,1));
var Threshold = 1*PIP;
ExitTime = 10*rDominantPeriod;
if(Amplitude(Dominant,100) > Threshold) {
if(valley(Signal))
reverseLong(1);
else if(peak(Signal))
reverseShort(1);
}
}
```
Здесь применен полосовой фильтр, центрированный по периоду доминантного цикла к ценовой кривой и измеряющий его амплитуду. Если амплитуда превышает установленный предел, то можно быть уверенным, что неэффективность есть, и действовать соответственно. Продолжительность сделки теперь также ограничена максимум 10 циклами, поскольку на втором этапе мы выяснили, что доминантный цикл появляется и исчезает на относительно небольших временных отрезках.
Что здесь может пойти не так? Ошибкой будет добавлять фильтр просто потому, что он улучшает результат теста. Любой фильтр должен иметь за собой рациональное обоснование, отталкиваясь от поведения рынка или сигналов алгоритма.
##### Шаг 5. Оптимизация параметров
Все параметры системы, так или иначе, влияют на результат. Но лишь несколько из них напрямую определяют точки входа и выхода из позиции, основываясь на ценовой кривой. Необходимо выявить и оптимизировать эти адаптируемые параметры. В нашем примере открытие позиции определяется фазой прогнозирования поведения кривой и порогом, установленным фильтром. Время закрытия сделки определено точкой выхода. Другие параметры, такие как постоянные фильтра DominantPhase и функция BandPass, нужно оптимизировать, поскольку их значения не зависят от ситуации на рынке.
Частенько оптимизацию трактуют неверно. Метод генетической или насильной оптимизации – это попытка найти пик выгоды в многомерном пространстве параметров. В большинстве случаев это не имеет отношения к работе живой системы. Хотя может получиться уникальная комбинация параметров, которая даст отличный результат теста. Даже совсем немного отличающиеся друг от друга исторические периоды дают совершенно разные пики. Вместо того чтобы гоняться за значением максимума прибыли на исторической кривой, оптимизация должна идти следующим путем:
* Она может определять чувствительность системы к значениям параметров. Если система пропускает свои границы при минимальном изменении параметров, лучше вернуться к шагу 3. Если исправить ситуацию не получается – обратно к первому этапу.
* Через оптимизацию можно найти активные точки параметров. Это зона, где параметры наиболее надежны, то есть, где даже небольшое изменение не оказывает существенного эффекта на положительный результат. Это не узкие пики, как можно было бы подумать, а широкие холмы в пространстве параметров.
* Она может адаптировать систему к различным активам и позволить работать с портфелем акций при минимальном изменении параметров.
* Она может увеличить срок службы системы через адаптацию параметров к текущей рыночной ситуации на регулярных интервалах, параллельно с процессом «живой» торговли.
Вот пример скрипта для оптимизации параметров:
```
function run()
{
vars Price = series(price());
var Phase = DominantPhase(Price,10);
vars Signal = series(sin(Phase+optimize(1,0.7,2)*PI/4));
vars Dominant = series(BandPass(Price,rDominantPeriod,1));
ExitTime = 10*rDominantPeriod;
var Threshold = optimize(1,0.7,2)*PIP;
if(Amplitude(Dominant,100) > Threshold) {
if(valley(Signal))
reverseLong(1);
else if(peak(Signal))
reverseShort(1);
}
}
```
Два оптимизированных вызова используют стартовое значение 1.0 и диапазон (0,7..2,0) для определения активных точек двух основных параметров. На диаграмме коэффициента прибыли эти точки отмечены красными столбцами:
В данном варианте оптимизатор выбирает значение параметра близкое к 1,3 для фазы синусоиды и значение 1,0 (не 0,9 для пика) для амплитуды порога для текущего соотношения в паре евро/доллар. Время выхода здесь не оптимизировано.
##### Шаг 6. Анализ за пределами выборки
Оптимизация параметров улучшает качество проверочного теста. Но наша система все еще не подогнана к ценовой кривой. Поэтому результаты теста для пока бесполезны. Теперь нужно разделить данные на циклы в выборке и за ее пределами. Выборка используется для обучения системы, анализ за пределами выборки — для тестирования. Стандартный метод для этого – [форвардный анализ](http://manual.zorro-project.com/numwfocycles.htm). Он использует динамичную выборку или скользящее окно для исторических данных для разделения двух циклов.
К сожалению, форвардный анализ добавляет два новых параметра к системе: время обучения и время тестирования. Второе не критично, главное, чтобы оно было сравнительно небольшим. Но вот время обучения имеет значение. Слишком короткое обучение не позволит получить достаточное количество данных по цене для эффективной оптимизации. Слишком длинное также негативно отразится на результате. Рынок может уже «переварить» изменения, пока будет проходить обучение. Поэтому время обучения само по себе нуждается в оптимизации.
Форвардный анализ с шагом в пять циклов (выставим NumWFOCycles = 5 в предыдущем скрипте) снижает производительность бэктеста со 100% годовой выручки к более реалистичным 60%. Для того чтобы избежать слишком оптимистичных результатов и ошибок в анализе, можно запустить его несколько раз с немного различающимися между собой условиями симуляции. Если система имеет свой предел, результаты не должны слишком разниться. В ином случае потребуется вернуться к шагу 3.
##### Шаг 7. Испытание реальностью
Даже пройдя стадию анализа за пределами выборки, мы все еще имеем некие искажение результата. Вызваны ли они ограничением самой системы или недостатками в процессе разработки (выбора актива, алгоритма, времени проверки и так далее)? Выяснить это – самая сложная часть в работе над трейдинговой стратегией.
Оптимальный вариант – использовать для этого метод под названием Тестирование реальности по методу Уайта (White’s Reality Check). Он же и наименее практичный, так как требует строгого порядка при выборе параметров и алгоритма. Два других метода не так хороши, но более удобны в применении:
* **Монте-Карло**. Предполагает рандомизацию ценовой кривой с помощью перетасовывания данных без их изменения. Затем необходимо провести обучение системы и протестировать ее снова, а потом проделать все еще раз и сгенерировать распределение результатов. Рандомизация удалит все ценовые аномалии. Но если результат реальной ценовой кривой окажется не так далеко от пика случайного распределения, он вероятно также вызван случайностью. Что это значит? Нужно вернуться к шагу 3.
* **Варианты**. Этот метод является противоположностью предыдущего. Он приспосабливает обучающуюся систему к разным вариантам ценовой кривой, чтобы получить положительный результат. Варианты, поддерживающие большинство аномалий, относятся к дискретизации с повышенной частотой, устраняют влияние тренда или инвертируют ценовую кривую. Если система остается в выигрыше с такими вариантами, но не со случайными ценами, вы действительно подобрали нечто стоящее.
* **ROOS-тест (Really-out-of-sample)**. Подразумевает полное исключение в процессе разработки данных за последний год (в примере — 2015-й) вплоть до удаления данных о движении цен с компьютера. И только, когда система будет полностью завершена, нужно загрузить данные за этот год и запустить тест. Здесь потребуется собрать всю волю в кулак, чтобы не стать переделывать систему, если она на этом последнем тесте не покажет желаемых результатов. Нужно просто отложить ее в сторону и вернуться к шагу 1.
##### Шаг 8. Управление рисками
Итак, система пережила все проверки. Теперь можно сконцентрировать усилия на снижении рисков и повышении ее производительности. Больше не нужно возвращаться к входным данным алгоритма и его параметрам. Нужно оптимизировать то, что будет получено на выходе. Вместо простого ограничение по времени и отмены для выхода можно использовать механизмы различных трейлинг-стопов. Например:
* Вместо выхода после заданного промежутка времени, нужно установить стоп-лосс на значение потери для каждого часа. Эффект будет схожим, но теперь закрытие неудачных сделок будет происходить быстрее, а удачных позже.
* Следует разместить стоп-лосс при достижении определенного значения профита над точкой отката значений. Даже если фиксация процента прибыли не улучшит общую производительность, это все равно будет полезно.
Вот пример скрипта, устанавливающий стоп-лоссы:
```
function run()
{
vars Price = series(price());
var Phase = DominantPhase(Price,10);
vars Signal = series(sin(Phase+optimize(1,0.7,2)*PI/4));
vars Dominant = series(BandPass(Price,rDominantPeriod,1));
var Threshold = optimize(1,0.7,2)*PIP;
Stop = ATR(100);
for(open_trades)
TradeStopLimit -= TradeStopDiff/(10*rDominantPeriod);
if(Amplitude(Dominant,100) > Threshold) {
if(valley(Signal))
reverseLong(1);
else if(peak(Signal))
reverseShort(1);
}
}
```
Разумеется, теперь придется еще раз пройти процесс оптимизации и форвардный анализ для параметров выхода.
##### Шаг 9. Распределение денежных средств
Процесс управления средствами преследует три цели. Во-первых, реинвестирвоать доходы. Во-вторых, грамотно распределить капитал внутри портфеля. В-третьих, вовремя понять, что торговый портфель бесполезен. В любом учебнике по трейдингу можно найти совет инвестировать 1% суммарного капитала за сделку. Эти вещи пишут люди, не заработавшие ни цента в реальной торговле.
Обозначим объем инвестиций за фиксированное время чрез V(t). Если система приносит доход, в среднем капитал C будет пропорционально расти с коэффициентом с.
Если следовать советам авторов умных книг и инвестировать фиксированный процент p от капитала, V(t) = p C(t), то капитал должен расти по экспоненте p c.
К несчастью, в это же время капитал будет испытывать на себе влияние случайных колебаний. Такие просадки будут пропорциональны торгуемому объему средств V(t). Это можно рассчитать с помощью формулы, где максимальная глубина просадки Dmax будет увеличиваться пропорционально квадратному корню от t.
Таким образом, при фиксированном значении инвестирования получаем:
И время в данном случае T = 1/(q p)2
Из этих расчетов можно видеть, как за период T просадка съест все деньги на счету. Не имеет значения, насколько хороша сама торговая система, и какой процент инвестирования выставил трейдер. Поэтому совет «вкладывать за раз 1%» — плохой совет. Вот почему автор блога Financial Hacker советует своим клиентам не поднимать торговый объем пропорционально к аккумулированной прибыли, но делать это на квадратный корень. Пока сама стратегия не исчерпает себя, это будет держать трейдера на безопасном расстоянии от [маржин-колла](https://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D1%80%D0%B6%D0%B8%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D1%82%D0%BE%D1%80%D0%B3%D0%BE%D0%B2%D0%BB%D1%8F#.D0.9E.D1.81.D0.BE.D0.B1.D0.B5.D0.BD.D0.BD.D0.BE.D1.81.D1.82.D0.B8_.D0.BC.D0.B0.D1.80.D0.B6.D0.).
В зависимости от того, работает ли трейдер с одним активом и одним алгоритмом или с их наборами, оптимальный объем инвестиций можно вычислить несколькими методами. Например, по формуле OptimalF Ральфа Винса или по формуле Келли от Эда Торпа. В большинстве случаев логично уйти от тяжеловесного кода для реализации процесса реинвестирования, поэтому объем инвестиций можно рассчитать и за пределами алгоритма. Особенно, если трейдер собирается снимать или класть деньги на счет время от времени. Удобную формулу для таких вещей можно найти в мануале [для языка Zorro](http://manual.zorro-project.com/kelly.htm).
##### Шаг 10. Подготовка к реальной торговле
Пришло время определиться с пользовательским интерфейсом для трейдинговой системы. Для этого необходимо понять, какие параметры нужно будет менять в режиме реального времени, а какие останутся постоянными. Далее следует приспособить к ней метод управления торговым объемом и реализовать «тревожную кнопку» для фиксирования прибыли и выхода в кэш при появлении плохих новостей. Необходимо отобразить все существенные параметры трейдинга в реальном времени, добавить возможности для переобучения системы и включить в нее метод сверки реальных результатов с результатами бэктеста. Трейдер должна убедиться, что сможет контролировать систему из любой точки пространства и времени. Это не означает, что ее нужно проверять каждые пять минут. Но иметь возможность за обедом взглянуть на результаты торговли с помощью мобильного телефона никогда не повредит.
#### Как все часто происходит в реальности
Выше мы описали разработку идеальной стратегии. Все это выглядит симпатично. Но как разработать реальную стратегию трейдинга? Понятно, что между теорией и практикой лежит пропасть — что, конечно, неправильно.
Вот как часто выглядит последовательность шагов по созданию стратегии работы на бирже, которую проделывают сотни и тысячи трейдеров:
**Шаг 1**. Зайти на форум трейдеров и получить подсказку о новом крутом индикаторе, который приносит баснословную выручку.
**Шаг 2**. Помучаться с кодом системы тестов, чтобы убедиться, что индикатор работает. Результаты бэктеста не впечатляют? В код закралась ошибка. Нужно сделать отладку, стараться еще лучше.
**Шаг 3**. Все еще нет результата, но трейдер уже осознает, что освоил и несколько полезных ходов. Можно еще добавить трейлинг-стоп. Теперь все выглядит немного лучше. Пора запускать недельный анализ. Вторник выпадает из стратегии? Нужно добавить фильтр, который пропускает торговлю по вторникам. Вписать еще несколько фильтров, которые блокируют открытие позиций между 10 и 12 утра, в случае, если котировка меньше $14,5, и в период полной луны. Следует подождать, пока моделирование завершится. Отлично, результаты бэктеста теперь хороши!
**Шаг 4**. Разумеется, никто не ведется просто на результат выборки. После оптимизации всех 23 параметров, трейдер запускает форвардный анализ. Ждет. Не нравится результат? Он пробует разные циклы этого анализа, разные периоды. Еще ждет. Наконец, нужные значения появятся.
**Шаг 5**. Система запускается в ходе реальных торгов.
**Шаг 6**. Итог не выглядит впечатляющим.
**Шаг 7**. После фиаско остается только ждать, пока банковский счет придет в себя. Некоторые трейдеры в такие периоды занимаются написаниями книг по торговле на бирже.
В следующем материале мы рассмотрим подход использования техники data mining в сочетании с машинным обучением для обнаружения паттернов с помощью различных алгоритмов и нейронных сетей. | https://habr.com/ru/post/281148/ | null | ru | null |
# Django multiple database support — теперь поддерживает множественные соединения с базами данных
Весь твиттер буквально кипит от это новости – django теперь поддерживает множественные соединения с базами данных. Фича [влита в транк](http://s3.amazonaws.com/bycoffe.baconfile.com/multidb.diff.txt) и [описана в документации](http://docs.djangoproject.com/en/dev/topics/db/multi-db/#topics-db-multi-db).
В документации (по ссылке выше) описан процесс настройки и использования нескольких баз данных в джанго:
# in settings.py:
`DATABASES = {
'default': {
'NAME': 'app_data',
'BACKEND': 'django.db.backends.postgres_psycopg2',
'USER': 'postgres_user',
'PASSWORD': 's3krit'
},
'users': {
'NAME': 'user_data'
'BACKEND': 'django.db.backends.mysql',
'USER': 'mysql_user',
'PASSWORD': 'priv4te'
}
}`
# in model lookups:
`Author.objects.using('default').all()`
# using('default') — явное указание БД для запроса. Если не указывать будет браться default
Подробней смотрите в документации! Поздравляю всех с этой новой фичей, мы давно ждали такой функциональности. Ура! | https://habr.com/ru/post/79062/ | null | ru | null |
# «А давайте выйдем на рынок СНГ»: как масштабировать сайт, если он к этому не готов
Рано или поздно у крупных проектов наступает такой этап, когда достигнут потолок по аудитории или финансовым показателям и нужно как-то расти дальше. И вот в один прекрасный день сияющие коллеги приходят к тебе со словами «Мы тут решили выйти на рынок США/Китая/СНГ…».
Если архитектура сайта изначально проектировалась с учетом международного развития — это хорошо. Однако если за все время жизни проекта вы концентрировались на том, что нужно «здесь и сейчас» и никто не задумывался о том, чтобы когда-нибудь вынести бизнес за пределы России, то могут возникнуть сложности.
Я тимлид финансового маркетплейса «Выберу.ру», сейчас допиливаю казахстанскую версию сайта на .NET. Хочу рассказать о нюансах, которые всплывают при масштабировании на другую страну, и о способах их поправить.
Полагаю, в ближайшее время все больше компаний будут рассматривать для себя зарубежные рынки. Если вам тоже предстоит адаптировать огромные объемы кода, который до этого годами создавался только для России — буду рад, если мой опыт окажется полезен.
### Подход к работе с геоданными
Первая проблема возникает на самом старте, если ваш сайт использует городские домены типа moskva.(домен).ru или tula.(домен).ru, а возможности приобрести домен первого уровня, например .kz, по каким-либо причинам нет. Как определять страну в этом случае?
Есть сущность регионов (*Region*), которая упрощенно выглядит так:
Под *Region* у нас были представленывсе географические сущности (страны, республики, области, города и т. д.). Мы добавили свойство *CountryId* и записали туда идентификатор региона-страны. Россия была добавлена первой (у неё Id = 1), Казахстан добавили позже. Теперь в базе несколько записей с *ParentId* = null — запись уровня страны.
Теперь надо научить сайт определять страну, для которой отображается страница. Тут есть несколько моментов:
* Если пользователь первый раз зашел на сайт и попал на страницу России (основной домен), то определяем его местоположение и предлагаем подтвердить наше решение.
* Если пользователь сразу зашел на домен города, например, moskva.(домен).ru или tula.(домен).ru, то вопрос о местоположении пользователя не задаем, а принимаем в качестве него город домена.
* Как только мы определили город пользователя, сразу можем определить и страну. Данные о городе и стране записываем в cookie. Эту запись пользователь может сменить, выбрав другой город или другую страну.
За счет этого мы можем реализовать механизм определения региона при каждом запросе по двум параметрам: из URL и из cookie, — обеспечивающим гибкость настроек. В случае с URL для определения страны и региона будем учитывать домены первого и третьего уровней соответственно. Для moskva.(домен).ru мы выберем город с Alias = «moskva». Для страны Alias = «ru» мы не найдем и используем значение по умолчанию — Россия (нюанс в том, что Alias России в нашей базе есть «www»).
### Вывод локализованных параметров
Когда мы научились определять страну, то можем выводить локализованные данные.
Что это может быть? Есть универсальные параметры: денежные единицы, формат даты. В зависимости от тематики сайта могут добавиться и другие. Например, для автомобильных агрегаторов — единицы скорости и расхода топлива, для объектов недвижимости — площади и расстояния и т. д. На финансовом ресурсе, чтобы показать, скажем, вклады в России, по умолчанию нужны доллары, евро и рубли, а в Казахстане потребовалось скрыть значки рублей и показать тенге (₸).
Просто взять и сделать это может быть не так просто — у нас, например, значок рубля местами был вшит в верстку, т. к. раньше он нужен был всегда. В результате где-то не вычислялось, какую валюту надо вывести, где-то в инструментах выбора валют всегда присутствовал рубль. И это сотни страниц: отчеты, графики на калькуляторах, результаты поиска, сумма «от» и «до».
Чтобы корректно выводить такие параметры, выносим данные о странах в отдельный файл (в нашем случае localization.json) и включаем в него следующее:
* название страны;
* домен для страны;
* имя культуры (для классов *CultureInfo и RegionInfo* во фреймворке .NET, помогающих форматировать даты, числа и другие параметры локализации в зависимости от страны, подробнее здесь [CultureInfo Конструктор (System.Globalization) | Microsoft Learn)](https://learn.microsoft.com/ru-ru/dotnet/api/system.globalization.cultureinfo.-ctor?view=net-6.0#system-globalization-cultureinfo-ctor(system-string));
* список доступных валют (или других нужных вам элементов);
* список разделов/функциональных возможностей сайта.
Загружаем файл при старте сайта. Данные из него доступны при выполнении запросов на сайт. Создаем для этого класс *CultureOptions* и получаем нужные данные для страны.
Выглядит так: LocalizationOptions localizationOptions = LocalizationOptions.Get(countryAlias).
Платформа .NET располагает расширенными методами для локализации/глобализации приложений. Приведенные классы платформы используем как:
* CultureInfo — для правильного вывода сумм, разделителей списков, форматирования текста ([CultureInfo Класс (System.Globalization) | Microsoft Learn](https://learn.microsoft.com/ru-ru/dotnet/api/system.globalization.cultureinfo?view=net-6.0)).
* RegionInfo — для получения значка валют ([RegionInfo.CurrencySymbol Свойство (System.Globalization) | Microsoft Learn](https://learn.microsoft.com/ru-ru/dotnet/api/system.globalization.regioninfo.currencysymbol?view=net-6.0#system-globalization-regioninfo-currencysymbol)).
### Настройка блоков контента под страну
Большая боль локализации — потребность скрывать или показывать конкретные блоки на страницах или целые разделы, чтобы пользователи из разных стран видели актуальный для их страны контент.
Для этого можно создать **систему управления конфигурацией**. С ее помощью все разделы, настройки региональности, локализация вынесены в отдельный блок кода — отдельную систему, где легко указать, что показывать или скрывать (это тот самый список фич из файла localization.json).
Так можно скрыть любую опцию или раздел, который еще не работает в другой стране, — на главной и везде, откуда в него можно попасть. Если в дальнейшем его нужно будет включить, сделать это будет легче: завести в админке новые организацию/продукт для нужной страны, заполнить данные и включить раздел.
Вот пример:
```
LocalizationOptions localizationOptions = LocalizationFeatures.GetOptions(country.Alias);
bool requestFormEnabled = localizationOptions
.IsEnabled(LocalizationOptionsNames.ProductListing.EnableRequestForm);
```
Если `requestFormEnabled` равен true, то выводим блок.
С точки зрения масштабирования система конфигурации открывает большие преимущества. Если понадобится подключить еще одну страну, например, Таджикистан — нужно будет ходить не по всему коду, а только в его изолированную часть. С его помощью можно завести новую страну, указать ее название, домен, валюту по умолчанию и протестировать на тестовом стенде перед тем, как пустить в релиз.
### Геонезависимые страницы
Итак, мы определили страну, вывели на нужных страницах локализованные данные и настроили индивидуальный набор разделов/функциональных элементов. Остались страницы продуктов, не привязанные к конкретному региону — мы называем их региононезависимые или геонезависимые. По умолчанию они отображаются по адресу www.(домен).ru.
Раньше у нас было так:
* зашли на moskva.(домен).ru — видим московские продукты;
* tula.(домен).ru — тульские продукты;
* (домен).ru — российские продукты.
Для Москвы родительский элемент геоструктуры — это www.(домен).ru — Россия. Если мы возьмем населенный пункт Снегири, он относится к Москве, у него родительский moskva, у того родительский www.(домен).ru — Россия. Все просто, тем более при отсутствии продуктов в Снегирях, можно показать продукты для всей России (для www). Однако теперь у нас несколько стран и просто выводить продукты для России (для www) не получится.
Если не менять логику и не научить продуктовый поиск учитывать разные страны, человек, находясь в разделе Казахстан, увидит содержимое, предназначенное для России. Для Казахстана нужно выводить не www.(домен).ru, а kz.(домен).ru как корневой узел страны пользователя. Выходит, если раньше поиск мог учитывать только один геопараметр (город), то теперь нужно закладывать два: город и страну.
Когда будем добавлять города, допустим, Астану, узловой элемент самого верхнего уровня будет kz, а не www. Соответственно, когда человек из Казахстана зайдет на страницу, которую мы считали раньше геонезависимой, он должен видеть не www.(домен).ru, а kz.(домен).ru как корневую страницу страны Казахстан.
### Оптимизация скорости загрузки
Когда мы оперируем странами, а не городами, возникает еще одна проблема — замедление работы сайта.
В нашей базе данных хранятся города, регионы, их названия со склонениями. Эти данные загружались в Redis и вынимались при необходимости — регион использовался для формирования текстов на сайте и других вычислений. Но как только мы стали вводить новые страны и чаще обращаться к данным регионов, количество запросов к Redis выросло в разы.
Теперь данные хранятся как полноценное дерево в памяти приложения (в памяти каждого экземпляра сайта), и доступ к ним значительно ускорен.
### Работа с текстами
В идеале при добавлении новой страны нужно перевести все тексты на иностранный язык. Это отдельная задача и много работы:
1. Вынести текст, который хранится в верстке и выдается (пункты меню, подписи на сайте) в ресурсы. Например, будем брать текст из ресурсов и выводить название меню. И вот этот ресурс мы будем писать для русского языка один, для иностранного — другой. В таком случае, переходя из страны в страну, мы будем видеть разный контент.
2. Подготовить SEO-тексты и описания продуктов. Тут доработка уже намного масштабнее. Сначала SEO-тексты нужно красиво написать на иностранном, оптимизировать. Потом описания продуктов в админке — проверить, адаптировать.
Нам повезло, что в Казахстане русский — официальный язык, поэтому адаптация текстов не стала критичным фактором для запуска и ушла на следующий этап доработок. Однако если вы масштабируете сайт для другого региона, скорее всего, эти работы придется внести в план до первого релиза.
---
К сожалению, заранее предусмотреть все возможные сценарии, в которые может занести ваш проект спустя годы, невозможно. Особенно это касается стартапов, которым «ничего не стоит» одномоментно принять решение выйти в новый продуктовый сегмент или страну.
Чаще всего в такой ситуации приходится пересматривать не отдельные части кода, а в целом логику и подход к работе — чтобы сайт не просто корректно отображался в конкретной стране, но и не упал в скорости загрузки и легко адаптировался под следующие сегменты/страны. | https://habr.com/ru/post/701872/ | null | ru | null |
# Компиляция. 1: лексер
Меня всегда завораживало таинство рождения программой программы. К сожалению, российские вузы уделяют мало внимания сей интереснейшей теме. Рассчитываю написать серию постов, в которых поэтапно создадим маленький работоспособный компилятор.
Первые посты серии уже подготовлены, и бета-тестировались в одном маленьком и наглухо закрытом сообществе. Тем не менее, я буду продолжать их править с учётом пожеланий почтенной хабрапублики.
### Далее в посте:
1. С какой стати писать компиляторы?
2. Общий план
3. Анализ текста
4. Практический пример
5. Как это работает?
### С какой стати писать компиляторы?
Разве не все нужные языки программирования уже написаны? Кому в наш просвещённый век может понадобиться писать собственный компилятор?
> Everything that can be invented has been invented.
>
> *--Charles H. Duell, Director of U.S. Patent Office, 1899 (attributed)*
> Что было, то и будет; и что делалось, то и будет делаться, и нет ничего нового под солнцем.
>
> *--Екклесиаст 1:9 (ок. 3 в. до н.э.)*
Во-первых, языки постоянно создаются и развиваются. Из ныне популярных, Ruby, PHP, Java и C# были *созданы* на нашей памяти, а бурно применяться начали несколько лет назад. Прямо сейчас Майкрософт проталкивает новый язык F#, и он — учитывая мощь Майкрософт — наверняка также войдёт в число общеупотребимых.
До сих пор остаются ниши для новых языков: например, не прекращаются попытки придумать *удобный* императивный язык для параллельного программирования.
Во-вторых, используемые в компиляции приёмы (в первую очередь, парсинг по грамматике) имеют массу других приложений. Часто есть потребность в преобразованиях source-to-source (рефакторинг, перевод кода на другой язык, и т.п.), когда нужно разобрать текст на языке программирования, обработать его, и вывести обработанный текст (на том же или на другом языке).
Безусловно, компиляция — довольно экзотичное занятие для программиста, где-нибудь в одном ряду с программированием ~~огромных боевых человекоподобных~~ роботов. Однако у всего этого есть практические применения, в отличие от многих других экстравагантных программистских хобби.
### Общий план
Процесс компиляции, в принципе, состоит из двух основных этапов:
1. Анализ текста на исходном языке
2. Генерация машинного кода
На первом этапе строится представление программы, с которым будет удобно работать дальше; обычно это дерево, но вовсе не обязательно. На втором этапе компилятор проходит по дереву, и для каждого узла генерирует окончательный код.
Самая challenging часть компилятора — оптимизация кода; на первом этапе выполняется высокоуровневая оптимизация, на уровне узлов дерева (например, разворачиваются циклы, вживляются inline-функции); на втором — низкоуровневая, на уровне потока команд (например, переупорядочиваются так, чтобы полнее нагрузить конвейеры конкретного процессора). До оптимизаций, по традиции, в вузовских курсах дело никогда не доходит; но самые простые (copy elimination, constant propagation) мы в нашем примере постараемся реализовать.
Старые посты на тему синтаксического разбора я на Хабре видел; но к генерации кода, вроде бы, авторы не приближались ни разу.
### Анализ текста
Когда начинающий программист пытается написать парсер текста, его естественный подход — рекурсивное углубление: найти начало конструкции (например, **{**); найти её конец (например, **}** на том же уровне вложенности); выделить содержимое конструкции, и пропарсить её рекурсивно.
Проблемы с таким подходом — во-первых, избыточная сложность (по одному и тому же фрагменту текста гуляем взад-вперёд); во-вторых, неудобство поддержки (синтаксис языка оказывается рассредоточен по килобайтам и килобайтам ветвистого кода).
Синтаксис языка можно задать декларативно; например, всем знакомы регулярные выражения. Идеально было бы написать стопочку регэкспов для всех конструкций языка, напротив каждого — определение узла, который должен создаться в дереве программы; «универсальный парсер» бы просто подставлял программу в один регэксп за другим, и создавал узлы согласно описанию, один за другим.
Первая из названных проблем решается тем, что поиск всех регэкспов в тексте можно выполнить за один проход, т.е. нет надобности хранить всю программу в памяти целиком — достаточно читать её по одному символу, обрабатывать символ, и тут же забывать.
Вторая — тем, что теперь у нас есть централизованное, формальное описание языка: можем менять регэкспы, вовсе не трогая код; и наоборот, менять код, не рискуя повредить парсер.
### Практический пример
Упомянутый «универсальный парсер», конечно же, давно реализован, и не одиножды. Классическая реализация — `lex` — принимает описания действий для каждого регэкспа на Си. В стандартные утилиты GNU входит `flex`, совместимый с `lex`, — его мы и будем использовать для примеров. (Есть аналогичные утилиты для C#, Java и пр.)
По традиции, первым примером станет написание калькулятора:
```
%{
#include
int reg = 0;
char op = '+';
int unmin = 0;
%}
%option main
%option yylineno
%%
[/][/].\*\n ; // comment
[0-9] { int opnd = atoi(yytext);
if (unmin) opnd =- opnd; unmin=0;
switch(op) {
case '+': reg += opnd; break;
case '-': reg -= opnd; break;
case '\*': reg \*= opnd; break;
case '/': reg /= opnd; break;
}
op = 0;
}
[-+\*/] { if (op) {
if (\*yytext=='-')
unmin = 1;
else {
printf("Unexpected operator in line %d\n", yylineno);
exit(1);
}
} else
op = \*yytext;
}
[;] { if (op) {
printf("Unexpected semicolon in line %d\n", yylineno);
exit(1);
}
printf("=%d\n", reg);
reg = 0;
op = '+';
}
[ \t\r\n] ; // whitespace
. { printf("Syntax error in line %d\n", yylineno); exit(1); }
%%
```
Имитируется калькулятор торговок с рынка: без скобок, без приоритета операций, без дробей. Выражения разделяются точкой с запятой, и можно вставлять комментарии от `//` до конца строки.
Скомпилируем наш калькулятор, и попробуем с ним поиграть:
`[tyomitch@home ~]$ **lex 1.lex**
[tyomitch@home ~]$ **cc lex.yy.c**
[tyomitch@home ~]$ **./a.out**
**2+2;**
=4
**2+2\*2;**
=8
**2 + // hello
- 3
;**=-1
**2 / /**
Unexpected operator in line 6`
#### Разбор кода
* Вверху, в тегах **%{ %}**, идёт код, который скопируется напрямик в парсер. Объявляем три переменные: `reg` («регистр») для промежуточного результата, `op` для набранной операции, и `unmin` — флаг, что был набран минус после знака операции, и он должен трактоваться как знак второго операнда.
* `%option main` указывает, что нас устроит стандартная `main` (которая читает с `stdin` до `EOF`). `%option yylineno` создаёт в парсере переменную `int yylineno`, где будет храниться номер текущей строки входного текста: он пригодится для диагностических сообщений.
* **%%** разделяет область объявлений и область собственно правил языка
* В каждом правиле слева пишется регэксп, справа — код на Си. В первом регэкспе код пуст; т.е. такая конструкция (а это коммментарий) будет просто игнорироваться. Аналогично, предпоследнее правило предписывает игнорировать пробелы и переводы строк между распознаваемыми конструкциями.
* Во втором правиле пользуемся переменной `yytext`: в ней хранится совпавший с регэкспом текст (в нашем случае, число-операнд)
* В третьем правиле — пример обработки ошибки в тексте программы (используем `yylineno` в тексте сообщения)
* Правила пробуются в порядке их появления, от первого к последнему. Если ни одно не подошло, парсер просто напечатает текущий символ в `stdout`. Вместо этого, мы добавляем последним правилом **.** — оно подойдёт к любому символу, и напечатает сообщение об ошибке.
В настоящем компиляторе, разумеется, правила будут не печатать результаты вычислений на экран, а сохранять сами выражения для последующей генерации кода.
##### Как это работает?
У математиков есть понятие ДКА (*детерминированный конечный автомат*) — штука, которая может находиться в одном из *N* состояний; которая читает из входного потока символ за символом; и у которой есть таблица: для каждого сочетания текущего состояния и прочитанного символа — в которое состояние перейти. Работа `flex` заключается в том, что он строит ДКА по заданному набору регэкспов; в некоторых состояниях этот ДКА не только переходит в следующее, но вдобавок вызвает наши правила.
Увидеть построенный ДКА можно, заглянув внутрь сгенерированного парсера `lex.yy.c`. Потребовалось 15 состояний. Для экономии места, таблица переходов хранится не в явном виде (размером 15х256), а разбитая на мудрёные накладывающиеся списки. Чтобы увидеть её в наиболее наглядной форме, скомпилируем парсер с опцией `-Cef` («отключить сжатие таблиц»):
```
static yyconst short yy_nxt[][8] =
{
{ 0, 0, 0, 0, 0, 0, 0, 0 },
{ 3, 4, 5, 6, 7, 8, 9, 10 },
{ 3, 4, 5, 6, 7, 8, 9, 10 },
{ -3, -3, -3, -3, -3, -3, -3, -3 },
{ 3, -4, -4, -4, -4, -4, -4, -4 },
{ 3, -5, -5, -5, -5, -5, -5, -5 },
{ 3, -6, -6, -6, -6, -6, -6, -6 },
{ 3, -7, -7, -7, -7, -7, -7, -7 },
{ 3, -8, -8, -8, -8, 11, -8, -8 },
{ 3, -9, -9, -9, -9, -9, 12, -9 },
{ 3, -10, -10, -10, -10, -10, -10, -10 },
{ 3, 13, 13, 14, 13, 13, 13, 13 },
{ 3, -12, -12, -12, -12, -12, 12, -12 },
{ 3, 13, 13, 14, 13, 13, 13, 13 },
{ 3, -14, -14, -14, -14, -14, -14, -14 },
} ;
static yyconst short int yy_accept[15] =
{ 0,
0, 0, 8, 6, 5, 5, 3, 3, 2, 4,
0, 2, 0, 1
} ;
```
Символы здесь разбиты на 8 классов, идентичных с точки зрения парсера (например, все цифры объединены в один класс). Отдельный массив `static yyconst int yy_ec[256]` ставит каждому символу в соответствие класс.
Основной цикл работы парсера весьма незамысловат:
```
yy_match:
while ( (yy_current_state = yy_nxt[yy_current_state][yy_ec[(unsigned char)(*yy_cp)]]) > 0 )
{
if ( yy_accept[yy_current_state] )
{
yy_last_accepting_state = yy_current_state;
yy_last_accepting_cpos = yy_cp;
}
yy_cp;
}
yy_current_state = -yy_current_state;
```
Положительные числа в таблице переходов означают «перейти в состояние и продолжить читать»; отрицательные — «перейти в состояние и выполнить действие». Номер действия, которое должно выполняться по приходу в состояние, хранится в `yy_accept`.
Рассмотрим пример: для цифр номер «класса символа» — 6.
В начальном состоянии (1) по символу 6 видим в таблице переходов 9. Переходим, читаем дальше.
В состоянии 9, если есть ещё одна цифра (6), переходим в состояние 12 и читаем дальше.
Из состояния 12, если есть ещё одна цифра, просто читаем дальше. (В таблице стоит 12)
Если увидели не-цифру (любой символ, кроме 6), нужно выполнить действие: видим в 9-ой строчке ряд из -9, и в 12-ой строчке ряд из -12.
Проверяем `yy_accept`: в обоих случаях применяем правило 2. (Вспомним, что правило, распознающее числа, в нашем парсере действительно второе.)
Непонятно, зачем `flex` решил разделить состояния 9 и 12, если в обоих делает одно и то же самое. Но он бездушная железяка, ему виднее.
Замечательно то, насколько готовый парсер прост: вместо ветвистого распознавания разных конструкций, у нас одна большая таблица, и цикл из десяти строк. Но есть существенная проблема. Вернёмся к примеру из самого начала поста: «найти начало конструкции (например, **{**); найти её конец (например, **}** *на том же уровне вложенности*)...» Как регэкспом обозначить условие «на том же уровне вложенности»?
Математики и тут постарались: доказали, что невозможно. Значит, для парсинга языков, поддерживающих вложенные конструкции (а это все языки сложнее BAT-файлов), нам потребуется более мощный инструмент, чем регэкспы. В следующий раз — [о нём](http://habrahabr.ru/blogs/programming/99298/). | https://habr.com/ru/post/99162/ | null | ru | null |
# Рисуем интерактивный линейный график на iOS с помощью Charts
Однажды бизнес попросил меня создать минималистичный график, который будет отображать сглаженную кривую с градиентом под ней. По этому графику можно перемещаться между значениями, водя пальцем. При этом за пальцем должна следовать вертикальная линия, а текущее значение должно отображаться в выноске — «баблике» с дополнительной информацией. В будущем хотелось бы заложить возможность поддержки нескольких графиков в одной координатной сетке. Версии iOS и Android должны быть максимально похожи. Примерно такие графики есть в системном приложении «Акции», в финансовых приложениях и фитнес-трекерах.
В этой статье я расскажу о библиотеке Charts и покажу на реальном примере, как создать свой первый график.
Поиск готовых решений
---------------------
После непродолжительного ресёрча становится ясно, что в этой задаче всё придумано за нас и изобретать велосипед не нужно. Для Android существует библиотека [MPAndroidChart](https://github.com/PhilJay/MPAndroidChart) (автор [Philipp Jahoda](https://github.com/PhilJay)), её аналог на iOS называется [Charts](https://github.com/danielgindi/Charts) (автор [Daniel Cohen Gindi](https://github.com/danielgindi)).
К плюсам Charts относятся:
* соответствие отображению на Android;
* поддержка обширной разновидности графиков;
* много возможностей кастомизации отображения данных;
* поддержка CocoaPods, Carthage, SPM.
Минусы:
* отсутствие подробной документации (я пользовался [документацией для Android](https://weeklycoding.com/mpandroidchart-documentation/));
* нехватка туториалов, чтобы на примерах понять общий подход к работе.
Итак, в итоге нужно будет прийти к следующему интерфейсу:
Экспериментировать с UI и сторонними библиотеками удобнее в отдельном проекте. К примеру, можно создать пустой проект и подключить в него Charts любым удобным способом. Я предпочитаю SPM, все доступные способы описаны на [странице Charts в Github](https://github.com/danielgindi/Charts). Объяснять начальный процесс создания проекта я не буду: думаю, все с этим знакомы. Итоговая версия проекта [доступна в Github](https://github.com/stepanovgena/LinearChartDemo).
Практика
--------
Попробуем создать первый простейший линейный график. Это нужно для понимания в общих чертах логики устройства Charts и того, что потребуется изменить, чтобы приблизиться к изначальным макетам.
Добавим такой код во viewDidLoad() нашего контроллера (не забываем про импорт Charts в заголовке файла):
```
override func viewDidLoad() {
super.viewDidLoad()
let lineChartEntries = [
ChartDataEntry(x: 1, y: 2),
ChartDataEntry(x: 2, y: 4),
ChartDataEntry(x: 3, y: 3),
]
let dataSet = LineChartDataSet(entries: lineChartEntries)
let data = LineChartData(dataSet: dataSet)
let chart = LineChartView()
chart.data = data
view.addSubview(chart)
chart.snp.makeConstraints {
$0.centerY.width.equalToSuperview()
$0.height.equalTo(300)
}
}
```
Для понимания логики можно двигаться по коду с конца. Область графика (chart) — это вьюшка, куда нужно передать какие-то данные. Вью имеет тип именно линейного графика, для столбчатых и иных диаграмм потребуется другой тип.
Передаваемые данные должны соответствовать типу графика, а именно — LineChartData. Этот тип принимает в конструктор некоторый датасет. Причём есть конструктор, где можно передать массив датасетов. Это важно, так как нам нужно заложить возможность поддержки нескольких графиков в одной координатной сетке.
Отлично, датасет тоже должен соответствовать типу линейного графика (LineChartDataSet). Наш датасет является некоторой абстракцией над массивом точек (entries), которые мы хотим отобразить. В базовом варианте каждая точка в свою очередь задаётся координатами X и Y — всё как в школе. С логикой разобрались, теперь посмотрим, что отобразилось на экране.
Понятно, что это совсем не похоже на рисунок дизайнера. Составим план изменений:
* поменять цвет графика;
* убрать точки на графике и их подписи к ним;
* добавить сглаживание;
* добавить градиент под графиком;
* убрать подписи на осях;
* убрать легенду;
* убрать координатную сетку.
Часть этих настроек относится к области графика, часть — к датасету. Это связано с тем, что в одной области может быть несколько графиков, и каждый — со своими настройками.
Область графика:
```
// отключаем координатную сетку
chart.xAxis.drawGridLinesEnabled = false
chart.leftAxis.drawGridLinesEnabled = false
chart.rightAxis.drawGridLinesEnabled = false
chart.drawGridBackgroundEnabled = false
// отключаем подписи к осям
chart.xAxis.drawLabelsEnabled = false
chart.leftAxis.drawLabelsEnabled = false
chart.rightAxis.drawLabelsEnabled = false
// отключаем легенду
chart.legend.enabled = false
// отключаем зум
chart.pinchZoomEnabled = false
chart.doubleTapToZoomEnabled = false
// убираем артефакты вокруг области графика
chart.xAxis.enabled = false
chart.leftAxis.enabled = false
chart.rightAxis.enabled = false
chart.drawBordersEnabled = false
chart.minOffset = 0
// устанавливаем делегата, нужно для обработки нажатий
chart.delegate = self
```
Фабрика датасетов
-----------------
Для настроек датасета перейдём на шаг вперёд. Мы сразу создадим фабрику датасетов на тот случай, когда в одной области может быть несколько графиков.
```
/// Фабрика подготовки датасета для графика
struct ChartDatasetFactory {
func makeChartDataset(
colorAsset: DataColor,
entries: [ChartDataEntry]
) -> LineChartDataSet {
var dataSet = LineChartDataSet(entries: entries, label: nil)
// общие настройки графика
dataSet.setColor(colorAsset.color)
dataSet.lineWidth = 3
dataSet.mode = .cubicBezier // сглаживание
dataSet.drawValuesEnabled = false // убираем значения на графике
dataSet.drawCirclesEnabled = false // убираем точки на графике
dataSet.drawFilledEnabled = true // нужно для градиента
addGradient(to: &dataSet, colorAsset: colorAsset)
return dataSet
}
}
private extension ChartDatasetFactory {
func addGradient(
to dataSet: inout LineChartDataSet,
colorAsset: DataColor
) {
let mainColor = colorAsset.color.withAlphaComponent(0.5)
let secondaryColor = colorAsset.color.withAlphaComponent(0)
let colors = [
mainColor.cgColor,
secondaryColor.cgColor,
secondaryColor.cgColor
] as CFArray
let locations: [CGFloat] = [0, 0.79, 1]
if let gradient = CGGradient(
colorsSpace: CGColorSpaceCreateDeviceRGB(),
colors: colors,
locations: locations
) {
dataSet.fill = .fillWithLinearGradient(gradient, angle: 270)
}
}
}
```
Работа с цветом
---------------
DataColor — это элементарная абстракция над UIColor, потому что требуется получать данные для построения графика из вьюмодели, но при этом не нужно, чтобы UIKit протекал в слой вьюмодели.
```
/// Абстракция над цветами UIColor
enum DataColor {
case first
case second
case third
var color: UIColor {
switch self {
case .first:
return UIColor(
red: 56/255,
green: 58/255,
blue: 209/255,
alpha: 1
)
case .second:
return UIColor(
red: 235/255,
green: 113/255,
blue: 52/255,
alpha: 1
)
case .third:
return UIColor(
red: 52/255,
green: 235/255,
blue: 143/255,
alpha: 1
)
}
}
```
Запустим проект и посмотрим, что получилось:
Затронуто всё, кроме обработки нажатий. Сейчас выделенное значение подсвечивается перекрестием жёлтого цвета. Теперь посмотрим, что можно настроить из коробки, а что придётся дописать вручную.
Для начала вернёмся в фабрику датасета и добавим эти настройки:
```
// оформление, связанное с выбором значения на графике
dataSet.drawHorizontalHighlightIndicatorEnabled = false // оставляем только вертикальную линию
dataSet.highlightLineWidth = 2 // толщина вертикальной линии
dataSet.highlightColor = colorAsset.color // цвет вертикальной линии
```
Теперь график должен отвечать на выбор значения вот так:
Остальное придётся создавать вручную:
* круг, которым выделяется значение;
* баблик для отображения атрибутов точки (дата, значение, легенда цвета).
Доработки
---------
Тут пригодятся два свойства области графика.
* Во-первых, у неё есть делегат
* Во-вторых, она умеет отображать маркеры. Для этого необходимо создать свой маркер с наследованием признаков базового класса MarkerView:
```
/// Круговой маркер для отображения выбранной точки на графике
final class CircleMarker: MarkerView {
override func draw(context: CGContext, point: CGPoint) {
super.draw(context: context, point: point)
context.setFillColor(UIColor.white.cgColor)
context.setStrokeColor(UIColor.blue.cgColor)
context.setLineWidth(2)
let radius: CGFloat = 8
let rectangle = CGRect(
x: point.x - radius,
y: point.y - radius,
width: radius * 2,
height: radius * 2
)
context.addEllipse(in: rectangle)
context.drawPath(using: .fillStroke)
}
}
```
Что касается баблика, примем простое решение: создадим кастомную view. Код для логики Charts не так важен. Реализацию можно посмотреть в итоговом проекте (ChartInfoBubbleView).
Из макета видно, что там должна отображаться дата, цветовая легенда данных и значение по оси Y. Важно: если графиков несколько, легенда и значения отображаются для каждого. Для соблюдения точности наборы данных для построения графиков должны иметь одинаковую размерность, потому что в них есть только дискретные данные и нет функции. Мы не можем подставить X и получить Y в произвольном месте.
Далее создадим обёртку над областью графика. Обёртка будет хранить саму область, маркер и выноску.
```
/// Вьюшка графика
final class ChartView: UIView {
private let chart = LineChartView()
private let circleMarker = CircleMarker()
private let infoBubble = ChartInfoBubbleView()
var viewModel: ChartViewModelProtocol? {
didSet {
updateChartDatasets()
}
}
override init(frame: CGRect) {
super.init(frame: frame)
commonInit()
}
required init?(coder: NSCoder) {
super.init(coder: coder)
commonInit()
}
}
```
Вернёмся к делегату, добавим для этого класса соответствие протоколу ChartViewDelegate. Тут нам интересны два метода:
* func chartValueSelected(\_ chartView: ChartViewBase, entry: ChartDataEntry, highlight: Highlight) — здесь мы получаем точку из датасета (entry). Данные из неё отправятся в баблик, а параметр highlight даст нам координаты точки на графике. Важный нюанс: тут нужно использовать свойства .xPx и .yPx, а не .x и .y, в которых не будет данных по координатам;
* func chartValueNothingSelected(\_ chartView: ChartViewBase) — здесь мы скрываем маркеры.
Добавление поддержки маркеров:
```
// маркеры
chart.drawMarkers = true
circleMarker.chartView = chart
chart.marker = circleMarker
```
Итоговый результат
------------------
На выходе получается следующее: нажатие отработалось методом делегата, мы показали круглый маркер на графике и баблик сбоку от него. При нажатии вне графика, но в его области, маркер и выноска скрываются. Чтобы выноска не выходила за края области графика, понадобится написать нехитрую логику, которая проверяет, помещается ли баблик на экран рядом с точкой или её нужно перенести на другую сторону от вертикальной черты и подвинуть по высоте. Пример такой реализации можно посмотреть в итоговом проекте:
Внимательный читатель заметит, что мы начинали с точек c координатами X и Y. И если X у нас соответствует просто порядковому номеру элемента в датасете, а Y — непосредственно значение измеряемой величины, то откуда взялась дата? Тут всё просто. Для ChartDataEntry существует несколько инициализаторов, один из которых — @objc public convenience init(x: Double, y: Double, data: Any?). В поле data мы передали дату, которая соответствует дате наблюдаемого значения, и достали её в коллбэке делегата при обработке нажатия.
Заключение
----------
Библиотека Charts даёт гибкие возможности для кастомизации графика, сохраняя единообразие между платформами iOS и Android. Это доказал простой пример, в котором мы прошли путь от дефолтной визуализации набора данных до реального кейса.
В рамках следующих шагов можно поразмышлять, как отобразить два, три, энное количество графиков в одной области и какие проблемы могут при этом возникнуть. | https://habr.com/ru/post/669854/ | null | ru | null |
# Как NodeJS обрабатывает множественные запросы?
Существует много путаницы по поводу конкурентности и параллелизма. Некоторые люди используют эти термины как взаимозаменяемые, но на самом деле они означают две разные вещи.
### Конкурентность
Конкурентность — это когда выполнение двух или более задач может начинаться, выполняться и завершаться в частично совпадающие (накладывающиеся друг на друга) периоды времени. Это вовсе не означает, что они будут выполняться одновременно, но их можно чередовать так, чтобы в любой момент времени всегда выполнялась одна задача.
Приведем пример
Официант принимает заказ от клиента со столика 1 и ждет, пока он будет готов.
После того как заказ будет готов, он выдает заказанные блюда клиентам. Затем переходит к следующему столу 2 клиента принимает заказ и идет на кухню, ожидая, пока он будет готов, после чего отдает еду клиенту.
Эффективно ли это? НЕТ, потому что официант ничем не занимается, пока заказ не будет готов.
Теперь официант идет к столу 1, принимает заказ и передает его на кухню, возвращается к столу 2, принимает заказ и передает его на кухню. Здесь официант не ждет, пока заказ будет готов, он идет принимать следующий заказ, пока еда готовится. Когда все будет готово, он подаст блюда на все столы. При этом, мы не увеличили количество официантов.
Аналогично происходит, когда мы не увеличиваем количество потоков, но ускоряем процесс, сокращая время простоя. Работа с множеством вещей в одно и то же время. Это процесс конкурентности.
Пример: во время приготовления пищи вам звонят, вы отвечаете на звонок, в то же время раздается сигнал кухонной плиты, вы возвращаетесь, выключаете плиту и снова отвечаете на звонок.
**Вы не выполняете что-то одно, а делаете две вещи одновременно, но по очереди.**
### Параллелизм
Параллелизм — это когда две или более задач могут действительно выполняться одновременно. Чтобы это произошло, задачи должны запускаться на разных процессорах или ядрах.
Приведем пример
Пока вы готовите еду, звонит телефон, ваша мама отвечает на звонок. Здесь две разные вещи происходят с двумя людьми, но в одно и то же время.
**Почему так важно понимать разницу?**
> Параллелизм важен, потому что он позволяет структурировать код таким образом, чтобы эффективно использовать ресурсы. Параллелизм важен, потому что он может значительно повысить производительность за счет выполнения нескольких действий одновременно.
>
>
Если вы пишете код, который будет выполняться на одном процессоре или ядре, то вам необходимо знать о конкурентности. Если ваш код будет выполняться на нескольких процессорах или ядрах, то нужно рассмотреть параллелизм.
### Что такое однопоточный процесс?
Однопоточный процесс — это выполнение запрограммированных инструкций в одной последовательности. Приложение имеет следующий набор инструкций:
Инструкция A
Инструкция B
Инструкция C
Если этот набор инструкций выполняется в однопоточном процессе, то это будет выглядеть следующим образом:
### Что такое многопоточный процесс?
Многопоточный процесс — это выполнение запрограммированных инструкций в нескольких последовательностях. Поэтому инструкциям не придется ждать завершения, если только некоторые из них не сгруппированы в разные последовательности.
### Почему Node.js является однопоточным?
NodeJS является однопоточной платформой. Это означает, что он может обрабатывать только один запрос за один раз.
Пример: Приняв заказ со стола 1 и передав его на кухню, официант идет к столу 2. В то время когда он принимает заказ со стола 2, еда для стола 1 уже готова, но официант не может сразу же подойти и передать готовое блюдо столу 1, он должен закончить обработку заказа со стола 2 и затем передать его на кухню. И только после этого он сможет передать готовое блюдо столу 1.
Веб-сервер NodeJS поддерживает ограниченный пул потоков (`limited Thread Pool`) для обслуживания клиентских запросов. Многочисленные клиенты делают множественные запросы к NodeJS-серверу. NodeJS получает эти запросы и помещает их в `EventQueue`.
Сервер NodeJS имеет внутренний компонент, называемый `EventLoop`, который представляет собой бесконечный цикл, принимающий запросы и обрабатывающий их. Этот EventLoop является однопоточным. Другими словами, `EventLoop` является слушателем для `EventQueue`.
### Как Node.js обрабатывает множественные запросы?
Событийно-ориентированная модель очень эффективна и позволяет NodeJS с легкостью обрабатывать тысячи одновременных запросов.
Node.js использует две концепции
* Неблокирующий ввод/вывод
* Асинхронный
Всякий раз, когда клиент посылает запрос, одиночный поток будет отправлять этот запрос кому-то другому. Текущий поток не будет занят обработкой этого запроса. Существуют воркеры, работающие на сервере. Сервер посылает запрос воркеру, тот дальше пересылает его другому серверу и ждет ответа. Тем временем, если поступит еще один запрос, поток отправит его другому воркеру, а тот будет ждать ответа от другого сервера.
Таким образом, одиночный поток всегда будет доступен для приема запросов от клиента. Он не будет их блокировать.
### Чем NodeJS лучше традиционной многопоточной модели ответа на запрос?
При традиционной многопоточной модели запросов/ответов каждый клиент получает отдельный поток, в то время как, как и в случае с NodeJS, более простые запросы обрабатываются непосредственно `EventLoop`. Это оптимизирует ресурсы пула потоков, и нет необходимости создавать потоки под каждый запрос клиента.
---
Скоро состоится открытое занятие, на котором обсудим проблему производительности в NodeJS. Найдем причины и способы ее решения. Если интересно, регистрируйтесь [по ссылке.](https://otus.pw/2Irh/) | https://habr.com/ru/post/703154/ | null | ru | null |
# 4 лучших паттерна проектирования автоматизированного тестирования (и еще 86)
***Всем привет. В преддверии старта курса [«Python QA Engineer»](https://otus.pw/HfQy/) подготовили перевод еще одного интересного материала.***
---
Большая часть успеха ваших проектов по автоматизации заключается в переиспользовании известных паттернов тестирования, которые, как уже доказано, помогают повысить надежность сценариев автоматизации.
Паттерн проектирования автоматизированного тестирования – это то простое решение, которое день ото дня доказывает миру свою эффективность. Эти шаблоны также считаются лучшими практиками для любого проекта, построенного за счет объектно-ориентированного программирования.
**Почему паттерны проектирования так важны для автоматизированного тестирования?**
Примите как данность то, что ваши приложения будут изменяться с течением времени.
И поскольку вы знаете, что изменения произойдут так или иначе, вам с самого начала следует использовать лучшие практики и паттерны проектирования. Они сделают ваши тесты переиспользуемыми и их будет легче поддерживать.
Вот несколько распространенных паттернов проектирования автоматизированного тестирования, которые используют многие команды для создания надежной автоматизации тестирования и улучшения всей логики тестирования.
#### Page Objects
*Пример Page Object Николая Адволодкина из Automation Guild 2017*
Одной из популярных стратегий, используемых при автоматизации тестирования, является моделирование поведения вашего приложения.
Для этого можно использовать простые page objects, которые моделируют те части программного обеспечения, которые вы тестируете.
Например, вы можете написать page object для страницы входа в систему или домашней страницы. Такой подход правильно отражает принцип единой ответственности.
Если что-то меняется, скажем, ID элемента, то нужно будет изменить всего лишь одно место в коде, а все тесты, использующие этот page object, автоматически получат это изменение без лишних действий. Код теста должен обновляться только в одном месте. Такой подход также помогает уменьшить дублирование кода.
Page objects также скрывают технические детали HTML и CSS за методами с простыми и понятными именами.
Внимательное отношение к именованию ваших методов имеет дополнительное преимущество, поскольку помогает создавать приятный читаемый программный интерфейс приложения (API), которым может быстро начать пользоваться менее технически подкованный программист.
Этот паттерн также придерживается популярной практики разработки программного обеспечения [DRY](https://testguild.com/clean-test-code/) (Don’t Repeat Yourself, не повторяйтесь).
В основном принцип DRY означает, что за каждую часть логики должен отвечать один кусок кода и не более. Дублирование в коде затрудняет его поддержку; чем меньше кода вы пишете, тем лучше, так как больше поддерживаемого кода означает больше шансов, что в ваш фреймворк для тестирования закрадется ошибка.
Один этот шаблон проектирования программного обеспечения сможет с легкостью решить основную часть ваших проблем при тестировании, однако он тоже не панацея. Тем не менее, он позволит вам сделать большой шаг вперед, сделав ваши автоматизированные функциональные тесты более стабильными.
Некоторые инженеры-тестировщики утверждают, что паттерн Page Object часто нарушает принцип, согласно которому, класс должен иметь только одну причину для изменения.
Чтобы избежать этого, многие обращаются к сценарию, который впервые был описан Энтони Маркано (`[@AntonyMarcano](https://twitter.com/AntonyMarcano)`) при участии Энди Палмера (`[@AndyPalmer](https://twitter.com/AndyPalmer)`), Яна Молака (`[@JanMolak](https://twitter.com/JanMolak)`) и других.
#### Паттерн Screenplay
Page objects – это хороший способ начать делать ваши тесты поддерживаемыми, но если вы не будете вести себя осторожно, они все равно могут со временем выйти из-под контроля.
Паттерн Screenplay (некогда известный как паттерн Journey) представляет из себя применение принципов проектирования [SOLID](https://en.wikipedia.org/wiki/SOLID) для автоматизированного приемочного тестирования и помогает командам решать эти проблемы. То есть, по сути, это то, что было результатом безжалостного рефакторинга Page Objects с использованием принципов проектирования SOLID.
Паттерн Screenplay берет page objects и разбивает их на действительно крошечные кусочки. Некоторые тестировщики говорят о том, что это сделало их тесты более ремонтопригодными и надежными.
Еще одним существенным преимуществом является то, что он делает тестовые сценарии более удобочитаемыми.
Впервые я услышал про [паттерн Screenplay на Automation Guild Session в 2017 году](https://guildconferences.com/speakersautomationguild2017/) от Джона Смарта (`[@Wakeleo](https://twitter.com/wakaleo))`, создателя одного из моих любимых фреймворков автоматизации тестирования, [Serenity](http://www.thucydides.info/).
Screenplay использует идею актеров, задач и целей для формального описания тестов, отказываясь от терминов взаимодействия с системой. В Screenplay вы описываете тесты в терминах актера, у которого есть цели.
Вот пример:
*Пример реализации паттерна Screenplay из Automation Guild Session 2017 от Джона Смарта*
На первый взгляд может показаться, что использовать этот паттерн гораздо сложнее, чем тот же Page Objects, однако Джон упомянул, что использование этого подхода экономит командам, с которыми он работал, много времени за счет уменьшения затрат на обслуживание и поддержку.
#### Порты и адаптеры
Архитектура портов и адаптеров направлена на то, чтобы убедиться, что вы используете [принцип единой ответственности](https://www.toptal.com/software/single-responsibility-principle), то есть конкретный объект должен делать что-то одно и иметь только одну причину для изменения.
Когда вы применяете его при автоматизации, убедитесь, что вы отделили код тест-кейса от всего остального, чтобы иметь возможность менять местами медленные компоненты и быстрые симуляторы, тем самым позволяя запускать тест и тестируемое приложение в одном процессе.
Избавьтесь от сетей и интерфейсов ввода/вывода, чтобы ничего не замедляло работу тестового набора. Конечно, сделать это нелегко, но чем больше вы будете к этому стремиться при создании автоматизации пользовательского интерфейса, тем лучше это будет для вас.
Я узнал об этом паттерне во время интервью с создателем [Cucumber](https://cucumber.io/), Аслаком Хеллесоем (`[@aslak\_hellesoy](https://twitter.com/aslak_hellesoy))`. Он описал его как стратегию получения быстрой обратной связи от сквозного тестирования Cucumber.
Аслак также порекомендовал ресурс, который называется [Todo-subsecond](https://github.com/subsecondtdd/todo-subsecond), который я добавил в свой пост [Top Resource for Test Automation Engineers](https://testguild.com/top-resources-for-test-automation-engineers/). Это крошечное приложение с full-stack приемочными тестами, которые могут выполняться за миллисекунды. Его цель заключается в том, чтобы проиллюстрировать основные методы достижения этого в любой системе. Прорешав серию упражнений, вы познакомитесь с особым способом реализации test-driven и behavior-driven разработки.
#### Presenter First
Presenter First – это модификация model-view-controller (MVC) для организации кода и разработки с целью создания полностью протестированного программного обеспечения с использованием test-driven подхода к разработке (TDD).
Впервые я узнал об этом паттерне из интервью с Сэб Роуз `[(@SebRose](https://twitter.com/sebrose)`), одного из контрибьюторов в проект Cucumber и автора книги Cucumber for Java.
Он говорил о том, что если вы нарисуете паттерн MVC в виде блоков и стрелок, то увидите, что представление, которое является вашим пользовательским интерфейсом, имеет четко определенные связи с моделью и контроллером. Если вы в рантайме можете заменить их моделями и контроллерами, которые создает и контролирует ваш тест, тогда не останется причин, по которым вы не сможете проверить, что пользовательский интерфейс ведет себя не так, как вы хотите.
Также вы можете настроить свою модель и контроллер так, чтобы они имитировали все виды странного поведения, например, выход сети из строя.
#### 86 других паттернов автоматизированного тестирования
Я написал эту статью много месяцев назад, но так и не опубликовал ее.
Я был уверен в своем списке, до того момента, как я поговорил с [Сереттой Гамба](https://www.linkedin.com/in/seretta-gamba-4597aa60/), автором новой книги [A Journey through Test Automation Patterns](https://amzn.to/2SLXf54), где она и ее соавтор [Дороти Грэхем](https://www.linkedin.com/in/dorothygraham/) рассказывают о 86 паттернах!
Они разбивают паттерны на четыре отдельные категории: паттерны процессов, паттерны управления, паттерны проектирования и паттерны выполнения.
Те, что я описал, относятся к шаблонам проектирования, но существует множество других паттернов, которые решают проблемы, связанные не только с кодом.
Например, есть паттерны, которые касаются плохой корпоративной культуры и моделей управления, которые, по моему опыту, как правило, сводят на нет все усилия по автоматизации тестирования.
Чтобы ознакомиться с полным списком, загляните в [wiki](https://testautomationpatterns.org/wiki/index.php/Main_Page) по вопросам паттернов проектирования или закажите себе книгу с Amazon.
[Узнать подробнее о курсе.](https://otus.pw/HfQy/) | https://habr.com/ru/post/493796/ | null | ru | null |
# Джулия и параллельные вычисления
С момента выхода в августе 2018, язык Julia активно набирает популярность, войдя в [топ 10 языков на Github](https://newsletter.juliacomputing.com/sendy/l/yUUX892w0QURpRZe20zeKxUw/CTWGjHMV892tWp6pxaMT763dwA/UOERLsbNmq9h8925EYuHjAtQ) и [топ 20 самых популярных профессиональных навыков по версии Upwork](https://newsletter.juliacomputing.com/sendy/l/0CwdQrfq0M8vc65F10dmrA/CT3YFMPo4wJuE5Vsy20ZYw/kEC8y1flJQ9L5RARUVx8892Q). Для начинающих [стартуют курсы](https://academy.juliabox.com) и [выпускаются](http://www.chkwon.net/julia/) [книги](http://mykel.kochenderfer.com/textbooks/). Julia используется для [планирования космических миссий](https://arc.aiaa.org/doi/10.2514/6.2018-1450), [фармакометрики](https://insp.memberclicks.net/assets/docs/Newslletters/ISOP%20Newsletter%20June%202019.pdf) и [климатического моделирования](https://my.nps.edu/-/nps-researchers-partner-on-next-generation-climate-model).
Перед тем как приступить к распределенным вычислениям в Julia обратимся к опыту тех, кто уже испробовал данную возможность нового ЯП для прикладных задач — от уравнения диффузии на двух ядрах, до астрономических карт на суперкомпьютере.
### Параллельные вычисления и факторы, влияющие на производительность параллельных вычислений
Большинство современных компьютеров имеют более одного процессора, а несколько компьютеров можно объединить в кластер. Использование мощности нескольких процессоров позволяет быстрее выполнять многие вычисления. На производительность влияют два основных фактора: скорость самих процессоров и скорость их доступа к памяти. В кластере данный ЦП будет иметь самый быстрый доступ к ОЗУ расположенной на том же компьютере или узле. Еще более удивительно, что подобные проблемы актуальны на типичном многоядерном ноутбуке из-за различий в скорости основной памяти и кеша. Следовательно, хорошая многопроцессорная среда должна позволять контролировать использование части памяти конкретным процессором.
### Параллельные вычисления в Julia
У Джулии есть несколько встроенных примитивов для параллельных вычислений на каждом уровне: векторизация (SIMD), многопоточность и распределенные вычисления.
Собственная многопоточность Джулии позволяет пользователю использовать возможности многоядерного ноутбука, в то время как примитивы удаленного вызова и удаленной выборки позволяют распределять работу по многим процессам в кластере. В дополнение к этим встроенным примитивам [ряд пакетов](https://github.com/JuliaParallel) в экосистеме Julia обеспечивает эффективную параллельную обработку.
#### Автоматическая векторизация в Julia
Современные чипы *Intel* предоставляют ряд расширений наборов команд. Среди них — различные версии Streaming SIMD Extension (SSE) и несколько поколений векторных расширений (доступны в последних семействах процессоров). Эти расширения обеспечивают программирование в стиле *Single Instruction Multiple Data (SIMD)*, обеспечивая значительное ускорение для кода, поддающегося такому стилю программирования. Мощный компилятор Julia на основе *LLVM* может автоматически генерировать высокоэффективный машинный код для базовых и пользовательских функций на любой архитектуре, такой как *SIMD Hardware* (поддерживаемая *LLVM*), что позволяет пользователю меньше беспокоиться о написании специализированного кода для каждой из этих архитектур. Еще одно преимущество использования компилятора для повышения производительности, а не для ручного кодирования «горячих циклов» в сборке, заключается в том, что это значительно лучше для будущего. Всякий раз, когда выходит архитектура набора команд следующего поколения, пользовательский код Julia автоматически становится быстрее.
#### Многопоточность
Многопоточность у Юлии обычно принимает форму параллельных циклов. Существуют также примитивы для блокировок и атомиков, которые позволяют пользователям синхронизировать свой код. Параллельные примитивы Джулии просты, но мощны. Показано, что они [масштабируются до тысяч узлов и обрабатывают терабайты данных](https://juliacomputing.com/case-studies/celeste.html).
#### Распределенные вычисления
Несмотря на то, что встроенных примитивов Julia достаточно для крупномасштабных параллельных развертываний, существует ряд пакетов для более специализированной работы. [ClusterManagers.jl](https://github.com/JuliaParallel/ClusterManagers.jl) предоставляет интерфейсы для ряда систем очередей заданий, обычно используемых в вычислительных кластерах, таких как *Sun Grid Engine* и *Slurm*. [DistributedArrays.jl](https://github.com/JuliaParallel/DistributedArrays.jl) предоставляет удобный интерфейс для массивов данных, распределенных по кластеру. Это объединяет ресурсы памяти нескольких машин, что позволяет использовать массивы, слишком большие для размещения на одной машине. Каждый процесс работает на той части массива, которой он владеет, предоставляя готовый ответ на вопрос о том, как программа должна быть разделена между машинами.
В некоторых унаследованных приложениях пользователи предпочитают не переосмысливать свою параллельную модель и хотят продолжать использовать параллелизм в стиле *MPI*. Для них [MPI.jl](https://github.com/JuliaParallel/MPI.jl) предоставляет тонкую оболочку вокруг *MPI*, которая позволяет пользователям использовать процедуры передачи сообщений в стиле MPI.
### Julia в боевых условиях
**The Celeste Project** — это сотрудничество *Julia Computing, Intel Labs, JuliaLabs@MIT, Lawrence Berkeley National Labs* и Калифорнийского университета в Беркли.
*Celeste* — это полностью генеративная иерархическая модель, которая использует статистический вывод для математического определения местоположения и характеристики источников света в небе. Эта модель позволяет астрономам определять перспективные галактики для нацеливания спектрографов и помогает понять роль темной энергии, темной материи и геометрию вселенной.
#### Пример из Sloan Digital Sky Survey (SDSS)
Используя собственные возможности параллельных вычислений Джулии, исследовательская группа Celeste обработала 55 терабайт визуальных данных и классифицировала 188 миллионов астрономических объектов всего за 15 минут, в результате чего был получен первый полный каталог всех видимых объектов из [Sloan Digital Sky Survey](https://ru.wikipedia.org/wiki/%D0%A1%D0%BB%D0%BE%D0%B0%D0%BD%D0%BE%D0%B2%D1%81%D0%BA%D0%B8%D0%B9_%D1%86%D0%B8%D1%84%D1%80%D0%BE%D0%B2%D0%BE%D0%B9_%D0%BD%D0%B5%D0%B1%D0%B5%D1%81%D0%BD%D1%8B%D0%B9_%D0%BE%D0%B1%D0%B7%D0%BE%D1%80). Это одна из крупнейших задач математической оптимизации, когда-либо решаемых человечеством.
В проекте Celeste использовалось 9 300 узлов *Knights Landing* (KNL) на суперкомпьютере *NERSC Cori Phase II* для выполнения 1,3 миллиона потоков на ядрах 650 000 KNL, что позволило объединить список приложений с быстродействием, **превышающим 1 петафлоп в секунду**, что делает Julia единственным динамичным языком высокого уровня, который когда-либо достиг такого подвига. *?? А синхронизация телескопов и обработка данных для снимка черной дыры 10.04.19 побила ли этот рекорд? Вроде как там по-большей части использовался Python*
#### Параллельное программирование с Julia с использованием MPI
> Перевод материала из блога Claudio занимающегося физикой плазмы 2018-09-30
Julia существует с 2012 года, и после более чем шести лет разработки, версия 1.0 была наконец выпущена. Это важный этап, который вдохновил меня на создание нового поста (после нескольких месяцев молчания). На этот раз мы увидим, как выполнять параллельное программирование в Julia с использованием парадигмы интерфейса передачи сообщений (MPI) через библиотеку с открытым исходным кодом Open MPI. Мы сделаем это, решив реальную физическую задачу: диффузию тепла через двумерную область.
Рисунок 1. Суперкомпьютер Sequoia в LLNL с почти 1,6 миллионами процессоров, доступных для численного моделирования ядерного оружия. hpc.llnl.gov
Это будет довольно продвинутое приложение MPI, нацеленное на тех, кто уже имеет некоторое представление о параллельных вычислениях. Из-за этого я не собираюсь идти шаг за шагом, а скорее сосредоточусь на конкретных аспектах, которые, по моему мнению, представляют интерес (в частности, использование ячеек-призраков и передача сообщений в двумерной сетке). Следуя традиции своих недавних постов, обсуждаемый здесь код будет выкладываться лишь частично. Это сопровождается полнофункциональным решением, которое вы можете найти на Github — [Diffusion.jl](https://github.com/cbellei/Diffusion.jl).
Параллельные вычисления вошли в «коммерческий мир» за последние несколько лет. Это стандартное решение для приложений ETL (Extract-Transform-Load), где рассматриваемая проблема смущающе параллельна: каждый процесс выполняется независимо от всех остальных, и не требуется никакой сетевой связи (пока не произойдет окончательный шаг «сокращения», где каждое локальное решение собрано в глобальное решение).
Во многих научных приложениях необходимо передавать информацию через сеть кластера. Эти «дожути параллельные» проблемы часто представляют собой численное моделирование: задачи астрофизики, моделирование погоды, биология, квантовые системы и т.д. В некоторых случаях эти симуляции выполняются на десятках и даже миллионах процессоров (рис. 1), а память распределяется между различными процессорами. Как правило, эти процессоры взаимодействуют в суперкомпьютере через парадигму интерфейса передачи сообщений (MPI).
Любой, кто работает в высокопроизводительных вычислениях, должен быть знаком с MPI. Он позволяет использовать архитектуру кластера на очень низком уровне. Теоретически, исследователь может назначить каждому ЦП свою вычислительную нагрузку. Он / она может точно решить, когда и какую информацию следует передавать между процессорами, и должно ли это происходить синхронно или асинхронно.
А теперь давайте вернемся к содержанию этого поста, где мы увидим, как написать решение уравнения диффузионного типа с использованием MPI. Мы уже [обсуждали](http://www.claudiobellei.com/2016/10/15/explicit-parabolic/) явную схему для одномерного уравнения этого типа (*Мы, кстати, тоже [такое обсуждали](https://habr.com/ru/post/429218/)*). Однако в этом посте мы рассмотрим двумерное решение.
Код Julia, представленный здесь, по сути является переводом кода *C / Fortran*, объясненного в том великолепном посте Фабьена Дурнака.
В этом посте я не буду подробно анализировать скорость масштабирования и количество процессоров. Главным образом потому, что у меня есть только два процессора, с которыми я могу играть дома (процессор Intel Core i7 на моем MacBook Pro)… Тем не менее, я все еще могу с гордостью сказать, что код Julia, представленный в этом посте, показывает значительное ускорение при использовании двух процессоров против одного. Да и вообще: **она быстрее, чем эквивалентные коды Fortran и C!** (подробнее об этом позже)
Вот темы, которые мы собираемся затронуть в этом посте:
* Юлия: Мои первые впечатления
* Как установить Open MPI на вашем компьютере
* Проблема: распространение через двумерный домен
* Связь между процессорами: потребность в призрачных ячейках
* Использование MPI
* Визуализация решения
* Производительность
* Выводы
### 1. Первые впечатления о Julia
На самом деле, я с Юлией познакомился недавно, поэтому решил здесь заостриться на паре «первых впечатлений».
Основная причина, по которой я заинтересовался Джулией, заключается в том, что она обещает быть фреймворком общего назначения с производительностью, сравнимой с *C* и *Fortran*, сохраняя при этом гибкость и простоту использования таких языков сценариев, как *Matlab* или *Python*. По сути, в Джулии должна быть возможность писать приложения *Data Science* / *High-Performance-Computing*, которые работают на локальном компьютере, в облаке или на корпоративных суперкомпьютерах.
Один аспект, который мне не нравится, — это рабочий процесс, который кажется неоптимальным для тех, кто, как я, ежедневно использует *IntelliJ* и *PyCharm* (плагин IntelliJ Julia ужасен). Я также попробовал [Juno IDE](https://juliacomputing.com/products/juliapro), это, пожалуй, лучшее решение на данный момент, но мне все еще нужно привыкнуть к нему.
Одним из аспектов, демонстрирующих, как Юлия еще не достигла своей «зрелости», является то, насколько разнообразной и устаревшей является документация многих пакетов (*для пакетов держащихся на плаву всё уже перелопатили с прошлого года*). Я до сих пор не нашел способа записать матрицу чисел с плавающей точкой на диск в отформатированном виде (*теперь уже [найти легко](https://docs.julialang.org/en/v1/stdlib/DelimitedFiles/#DelimitedFiles.writedlm)*). Конечно, вы можете записать на диск каждый элемент матрицы в цикле double-for, но должны быть доступны лучшие решения. Просто эту информацию трудно найти, а документация обязана быть исчерпывающей.
Другим аспектом, который выделяется при первом использовании Julia, является выбор использования индексации с единицы для массивов. Хотя я нахожу это немного раздражающим с практической точки зрения, это, конечно, не нарушает договоренности, учитывая, что это не уникально для Джулии (Matlab и Fortran также используют индексацию начинающуюся с одного).
Теперь, к хорошему и самому важному аспекту: Джулия действительно может быть очень быстрой. Я был впечатлен, увидев, как код Julia, который я написал для этого поста, может работать лучше, чем эквивалентный код на Fortran и C, несмотря на то, что по сути только что перевел его на Julia. Посмотрите на раздел производительности, если вам интересно.
### 2. Установка Open MPI
Open MPI — это библиотека интерфейса передачи сообщений с открытым исходным кодом. Другие известные библиотеки включают MPICH и MVAPICH. MVAPICH, разработанный Университетом штата Огайо, на данный момент является самой продвинутой библиотекой, поскольку она также может поддерживать кластеры графических процессоров — что особенно полезно для приложений Deep Learning (действительно, между NVIDIA и командой MVAPICH существует тесное сотрудничество).
Все эти библиотеки построены на общем интерфейсе: MPI API. Поэтому не имеет значения, используете ли вы одну или другую библиотеку: написанный вами код может остаться прежним.
Проект [MPI.jl](https://github.com/JuliaParallel/MPI.jl) на Github — это оболочка для MPI. Под капотом он использует C и Fortran установки MPI. Он отлично работает, хотя ему не хватает некоторых функций, доступных на этих других языках.
Чтобы запустить MPI в Julia, вам нужно будет установить отдельно Open MPI на ваш компьютер. Если у вас есть Mac, я нашел [это руководство](https://wiki.helsinki.fi/display/HUGG/Open+MPI+install+on+Mac+OS+X) очень полезным. Важно отметить, что вам также потребуется установить *gcc* (компилятор GNU), поскольку для Open MPI требуются компиляторы Fortran и C. Я установил версию Open MPI 3.1.1, что также подтверждается `mpiexec --version` на моем терминале.
После того, как на вашем компьютере установлен Open MPI, вы должны установить *cmake*. Опять же, если у вас Mac, это так же просто, как набрать `brew install cmake` на вашем терминале.
На данный момент вы готовы установить пакет MPI в Julia. Откройте Julia REPL и введите `using Pkg` `Pkg.add («MPI»)`. Обычно в этот момент вы должны иметь возможность импортировать пакет, используя MPI для импорта. Однако мне также пришлось собрать пакет через `Pkg.build («MPI»)`, прежде чем все заработало.
### 3. Задача: двумерное уравнение диффузии
Уравнение диффузии является примером параболического уравнения в частных производных. Он описывает такие явления, как диффузия тепла или диффузия концентрации (второй закон Фика). В двух пространственных измерениях уравнение диффузии записывается
Решение  показывает, как изменяется температура / концентрация (в зависимости от того, изучаем ли мы распространение тепла или диффузию веществ) в пространстве и времени. Действительно, переменные **x** и **y** представляют пространственные координаты, а временная компонента представлена переменной **t**. Величина **D** является «коэффициентом диффузии» и определяет, как быстро, например, тепло будет распространяться через физическую область. Аналогично тому, что обсуждалось (более подробно) в предыдущем посте блога, приведенное выше уравнение может быть дискретизировано с использованием так называемой «явной схемы» решения. Я не буду вдаваться в подробности, которые вы можете найти в блоге, достаточно записать числовое решение в следующей форме:
где `i` и `k` индексы пробегающие по пространственной сетке, `j` по времени. Первый временной слой заполняется из начальных условий, а каждый последующий  вычисляется с использованием значений предыдущего слоя. На рисунке красными кружочками обозначены узлы слоя , которые нужны для вычисления значения в точке 
Уравнение (1) действительно все, что нужно для того, чтобы найти решение по всей области на каждом последующем временном шаге. Довольно просто реализовать код, который делает это последовательно, с одним процессом на CPU. Однако здесь мы хотим обсудить параллельную реализацию, которая использует несколько процессов.
Каждый процесс будет отвечать за поиск решения в части всей пространственной области. Такие проблемы, как диффузия тепла, которые не являются явнымии претендентами на распределенные вычисления, требуют обмена информацией между процессами. Чтобы прояснить этот момент, давайте посмотрим на рисунок
*Два соседних процесса должны взаимодействовать, чтобы найти решение вблизи границы. Процесс 0 должен знать значение решения в B, чтобы рассчитать решение в точке сетки A. Аналогично, процесс 1 должен знать значение в точке C, чтобы вычислить решение в точке сетки D. Эти значения неизвестны процессам, пока не произойдет связь между процессами 0 и 1.*
Он показывает, как процессы 0 и 1 должны будут взаимодействовать, чтобы оценить решение вблизи границы. Тут-то на сцену и выходит MPI. В следующем разделе мы рассмотрим эффективный способ обмена сообщениями.
### 4. Связь между процессами: призрачные ячейки
Важным понятием в вычислительной гидродинамике является понятие призрачных ячеек. Эта концепция полезна всякий раз, когда пространственный домен разлагается на несколько поддоменов, каждый из которых решается одним процессом.
Чтобы понять, что такое призрачные ячейки, давайте снова рассмотрим две соседние области на предыдущем изображении. Процесс 0 отвечает за поиск решения с левой стороны, тогда как процесс 1 находит его с правой стороны пространственного домена. Однако из-за формы трафарета (рис. 2) вблизи границы оба процесса должны будут обмениваться данными между собой. Вот проблема: очень неэффективно, чтобы процесс 0 и процесс 1 связывались каждый раз, когда им нужен узел из соседнего процесса: это привело бы к неприемлемым издержкам связи.
*Рис.4 Связь между процессами без (слева) и с (справа) призрачными клетками. Без промежуточных ячеек каждая ячейка на границе субдомена должна передавать свое собственное сообщение соседнему процессу. Использование ячеек-призраков позволяет минимизировать количество передаваемых сообщений, так как многие ячейки, принадлежащие границам процесса, обмениваются одновременно одним сообщением. Здесь, например, процесс 0 передает всю северную границу процессу 1, а всю восточную границу процессу 2.*
Вместо этого, обычной практикой является окружение «настоящих» поддоменов дополнительными ячейками, называемыми ячейками-призраками, как показано на рисунке 4 (справа). Эти клетки-призраки представляют собой копии решения на границах соседних поддоменов. На каждом временном шаге старая граница каждого субдомена передается соседям. Это позволяет рассчитывать новое решение на границе субдомена со значительно сниженными накладными расходами на связь. Чистый эффект — ускорение в коде.
### 5. Использование MPI
Существует множество учебных пособий по MPI. Здесь я просто хочу описать те команды, выраженные на языке оболочки MPI.jl для Джулии, которые я использовал для решения проблемы двумерной диффузии. Это некоторые основные команды, которые используются практически в каждой реализации MPI.
**MPI команды**`MPI.init ()` — инициализирует среду исполнения
`MPI.COMM_WORLD` — представляет коммуникатор, т. Е. Все процессы, доступные через приложение MPI (каждое сообщение должно быть связано с коммуникатором)
`MPI.Comm_rank (MPI. COMM_WORLD)` — определяет внутренний ранг (id) процесса
`MPI.Barrier (MPI.COMM_WORLD)` — блокирует выполнение до тех пор, пока все процессы не достигнут этой процедуры
`MPI.Bcast! (Buf, n_buf, rank_root, MPI.COMM_WORLD)` — широковещательные сообщения буфер buf с размером n\_buf от процесса с рангом rank\_root ко всем остальным процессам в коммуникаторе MPI.COMM\_WORLD
`MPI.Waitall! (reqs)` — ожидает завершения всех MPI-запросов (запрос является дескриптором, другими словами, ссылкой, для асинхронной передачи сообщений)
`MPI.REQUEST_NULL` — указывает, что запрос не связан ни с какой продолжающейся связью
`MPI.Gather (buf, rank_root, MPI.COMM_WORLD)` — уменьшает переменную buf до процесса получения rank\_root
`MPI.Isend (buf, rank_dest, tag, MPI.COMM_WORL D)` — сообщение buf отправляется асинхронно от текущего процесса в процесс rank\_dest, причем сообщение помечается тегом с параметром
`MPI.Irecv! (Buf, rank_src, tag, MPI.COMM_WORLD)` — получает сообщение с тегом tag из исходный процесс ранга rank\_src в локальный буфер buf
`MPI.Finalize ()` — завершает среду исполнения MPI
#### 5.1 Нахождение соседей процесса
Для нашей задачи мы собираемся разложить нашу двумерную область на множество прямоугольных субдоменов, как показано на рисунке ниже.
*Рисунок 5. Декартовое разложение двумерной области, разделенной на 12 субдоменов. Обратите внимание, что ранги MPI (идентификаторы процессов) начинаются с нуля.*
Обратите внимание, что оси `x` и `y` перевернуты относительно обычного использования, чтобы связать ось x со строками и ось y со столбцами матрицы решения.
Чтобы общаться между различными процессами, каждый процесс должен знать своих соседей. Существует очень удобная команда MPI, которая делает это автоматически и называется `MPI_Cart_create`. К сожалению, оболочка Julia MPI не включает эту продвинутую команду (и ее добавление не кажется тривиальной), поэтому вместо этого я решил создать функцию, которая выполняет ту же задачу. Чтобы сделать её более компактной, я часто использовал [тернарный оператор](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D1%80%D0%BD%D0%B0%D1%80%D0%BD%D0%B0%D1%8F_%D1%83%D1%81%D0%BB%D0%BE%D0%B2%D0%BD%D0%B0%D1%8F_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D1%8F). Вы можете найти эту функцию ниже
**Код**
```
function neighbors(my_id::Int, nproc::Int, nx_domains::Int, ny_domains::Int)
id_pos = Array{Int,2}(undef, nx_domains, ny_domains)
for id = 0:nproc-1
n_row = (id+1) % nx_domains > 0 ? (id+1) % nx_domains : nx_domains
n_col = ceil(Int, (id + 1) / nx_domains)
if (id == my_id)
global my_row = n_row
global my_col = n_col
end
id_pos[n_row, n_col] = id
end
neighbor_N = my_row + 1 <= nx_domains ? my_row + 1 : -1
neighbor_S = my_row - 1 > 0 ? my_row - 1 : -1
neighbor_E = my_col + 1 <= ny_domains ? my_col + 1 : -1
neighbor_W = my_col - 1 > 0 ? my_col - 1 : -1
neighbors = Dict{String,Int}()
neighbors["N"] = neighbor_N >= 0 ? id_pos[neighbor_N, my_col] : -1
neighbors["S"] = neighbor_S >= 0 ? id_pos[neighbor_S, my_col] : -1
neighbors["E"] = neighbor_E >= 0 ? id_pos[my_row, neighbor_E] : -1
neighbors["W"] = neighbor_W >= 0 ? id_pos[my_row, neighbor_W] : -1
return neighbors
end
```
> Подобное мы делали когда [строили лабиринты](https://habr.com/ru/post/451460/)
Входными данными этой функции являются `my_id`, который является рангом (или идентификатором) процесса, число процессов `nproc`, число делений в направлении **x** `nx_domains` и количество делений в направлении **y** `ny_domains`.
Давайте сейчас проверим эту функцию. Например, снова глядя на рис. 5, мы можем проверить выходные данные для процесса ранга 4 и процесса ранга 11. Вобьём в REPL:
```
julia> neighbors(4, 12, 3, 4)
Dict{String,Int64} with 4 entries:
"S" => 3
"W" => 1
"N" => 5
"E" => 7
```
и
```
julia> neighbors(11, 12, 3, 4)
Dict{String,Int64} with 4 entries:
"S" => 10
"W" => 8
"N" => -1
"E" => -1
```
Как видите, я использую кардинальные направления "N", "S", "E", "W" для обозначения местоположения соседа. Например, процесс 4 имеет процесс 3 в качестве соседа, расположенного к югу от его позиции. Вы можете проверить, что все вышеприведенные результаты верны, учитывая, что «-1» во втором примере означает, что не было найдено соседей на "северной" и "восточной" сторонах процесса 11.
#### 5.2 Передача сообщений
Как мы видели ранее, на каждой итерации каждый процесс отправляет свои границы соседним процессам. В то же время каждый процесс получает данные от своих соседей. Эти данные хранятся каждым процессом в виде "призрачных ячеек" и используются для вычисления решения вблизи границы каждого субдомена.
В MPI есть очень полезная команда `MPI_Sendrecv`, которая позволяет отправлять и получать сообщения одновременно между двумя процессами. К сожалению, MPI.jl не обеспечивает эту функциональность, однако все еще возможно достичь того же результата, используя функции `MPI_Send` и `MPI_Receive` отдельно.
Вот что сделано в следующей функции `updateBound!`, которая обновляет ячейки-призраки на каждой итерации. Входными данными этой функции являются глобальное 2D-решение u, которое включает в себя призрачные ячейки, а также всю информацию, относящуюся к конкретному процессу, выполняющему функцию (каков ее ранг, каковы координаты ее субдомена, каковы его соседи). Функция сначала отправляет свои границы соседям, а затем получает их границы. Принимающая часть дорабатывается через команду `MPI.Waitall!`, которая гарантирует, что все ожидаемые сообщения были получены до обновления побочных ячеек для конкретного поддомена, представляющего интерес.
**Код**
```
function updateBound!(u::Array{Float64,2}, size_total_x, size_total_y, neighbors, comm,
me, xs, ys, xe, ye, xcell, ycell, nproc)
mep1 = me + 1
#assume, to start with, that this process is not going to receive anything
rreq = Dict{String, MPI.Request}(
"N" => MPI.REQUEST_NULL,
"S" => MPI.REQUEST_NULL,
"E" => MPI.REQUEST_NULL,
"W" => MPI.REQUEST_NULL
)
recv = Dict{String, Array{Float64,1}}()
ghost_boundaries = Dict{String, Any}(
"N" => (xe[mep1]+1, ys[mep1]:ye[mep1]),
"S" => (xs[mep1]-1, ys[mep1]:ye[mep1]),
"E" => (xs[mep1]:xe[mep1], ye[mep1]+1),
"W" => (xs[mep1]:xe[mep1], ys[mep1]-1)
)
is_receiving = Dict{String, Bool}("N" => false, "S" => false, "E" => false, "W" => false)
#send
neighbors["N"] >=0 && MPI.Isend(u[xe[mep1], ys[mep1]:ye[mep1]], neighbors["N"], me + 40, comm)
neighbors["S"] >=0 && MPI.Isend(u[xs[mep1], ys[mep1]:ye[mep1]], neighbors["S"], me + 50, comm)
neighbors["E"] >=0 && MPI.Isend(u[xs[mep1]:xe[mep1], ye[mep1]], neighbors["E"], me + 60, comm)
neighbors["W"] >=0 && MPI.Isend(u[xs[mep1]:xe[mep1], ys[mep1]], neighbors["W"], me + 70, comm)
#receive
if (neighbors["N"] >= 0)
recv["N"] = Array{Float64,1}(undef, ycell)
is_receiving["N"] = true
rreq["N"] = MPI.Irecv!(recv["N"], neighbors["N"], neighbors["N"] + 50, comm)
end
if (neighbors["S"] >= 0)
recv["S"] = Array{Float64,1}(undef, ycell)
is_receiving["S"] = true
rreq["S"] = MPI.Irecv!(recv["S"], neighbors["S"], neighbors["S"] + 40, comm)
end
if (neighbors["E"] >= 0)
recv["E"] = Array{Float64,1}(undef, xcell)
is_receiving["E"] = true
rreq["E"] = MPI.Irecv!(recv["E"], neighbors["E"], neighbors["E"] + 70, comm)
end
if (neighbors["W"] >= 0)
recv["W"] = Array{Float64,1}(undef, xcell)
is_receiving["W"] = true
rreq["W"] = MPI.Irecv!(recv["W"], neighbors["W"], neighbors["W"] + 60, comm)
end
MPI.Waitall!([rreq[k] for k in keys(rreq)])
for (k, v) in is_receiving
if v
u[ghost_boundaries[k][1], ghost_boundaries[k][2]] = recv[k]
end
end
end
```
### 5. Визуализация решения
Домен инициализируется постоянным значением `u = +10` вокруг границы, что можно интерпретировать как наличие источника постоянной температуры на границе. Начальное условие `u = −10` внутри области (рис. 6 слева). С течением времени значение `u = 10` на границе диффундирует к центру области. Например, на этапе `j = 15203` решение выглядит так, как показано на рис. 6 справа.
С увеличением времени **t** решение становится все более однородным, пока теоретически для  оно не станет `u = +10` по всему домену.
*Рис. 6. Начальное условие (слева) и решение на шаге 15203 по времени (справа). Границы области всегда сохраняются на значении u = +10. С течением времени решение становится все более однородным и имеет тенденцию становиться все ближе и ближе к значению u = +10 по всей области.*
### 6. Производительность
Я был очень впечатлен, когда проверил производительность реализации Julia по сравнению с Fortran и C: я обнаружил, что реализация Julia самая быстрая!
Прежде чем углубляться в сравнение, давайте посмотрим на производительность MPI самого кода Julia. На рисунке 7 показано соотношение времени выполнения при работе с процессами 1 к 2 (ЦП). В идеале вы хотели бы, чтобы это число было близко к 2, т.е. работа с двумя процессорами должна быть в два раза быстрее, чем с одним процессором. Вместо этого наблюдается то, что для небольших размеров задач (сетка из 128x128 ячеек) время компиляции и накладные расходы на коммуникацию оказывают отрицательное влияние на общее время выполнения: ускорение меньше единицы. Преимущество использования нескольких процессов становится очевидным только для более крупных задач.
*Рисунок 7. Ускорение реализации Julia MPI с двумя процессами против одного процесса в зависимости от сложности задачи (размера сетки). Под «ускорением» подразумевается отношение общего времени выполнения с использованием 1 процесса к 2 процессам.*
А теперь неожиданный поворот: на рис. 8 показано, что реализация Julia быстрее, чем Fortran и C, для задач размером 256x256 и 512x512 (только те, которые я тестировал). Здесь я только измеряю время, необходимое для завершения основного цикла итерации. Я считаю, что это справедливое сравнение, поскольку для длительных симуляций это будет самым большим вкладом в общее время выполнения.
*Рисунок 8. Производительность Julia против Fortran против C для двух размеров сетки: 256x256 (вверху) и 512x512 (внизу). Это показывает, что Джулия — лучший исполнительский язык. Производительность измеряется как время, необходимое для выполнения фиксированного числа итераций в основном цикле кода.*
### Выводы
Прежде чем начать этот пост, я скептически относился к тому, что Джулия может конкурировать со скоростью Фортрана и Си для научных приложений. Основная причина заключалась в том, что я ранее перевел академический код, содержащий около 2000 строк, из Фортрана в Julia 0.6, и я заметил снижение производительности примерно в 3 раза.
Но на этот раз… я очень впечатлен. Я фактически только что перевел существующую реализацию MPI, написанную на Фортране и Си, на Julia 1.0. Результаты, показанные на рис. 8, говорят сами за себя: Юлия, похоже, самая быстрая на сегодняшний день. Обратите внимание, что я не учел длительное время компиляции, потребляемое компилятором Julia, поскольку для «реальных» приложений, для выполнения которых требуются часы, это будет незначительным фактором.
Я также должен добавить, что мои тесты, конечно, не настолько исчерпывающие, как должны быть для тщательного сравнения. На самом деле, мне было бы любопытно посмотреть, как работает код более чем с двумя процессорами (я ограничен моим домашним персональным ноутбуком) и с другим оборудованием (см. [Diffusion.jl](https://github.com/cbellei/Diffusion.jl)).
Во всяком случае, это упражнение убедило меня в том, что стоит потратить больше времени на изучение и использование Julia для Data Science и научных приложений. Вперёд, к новым свершениям!
*References*
* [Version MPI du code de résolution numérique de l’équation de chaleur 2D](https://dournac.org/info/parallel_heat2d)
* [Parallel Computing](https://juliacomputing.com/domains/parallel-computing.html)
* [Parallel programming with Julia using MPI](http://www.claudiobellei.com/2018/09/30/julia-mpi/#mjx-eqn-eqdiffusion)
* [Celeste programm](https://juliacomputing.com/case-studies/celeste.html) | https://habr.com/ru/post/454998/ | null | ru | null |
# Openstack. Детективная история или куда пропадает связь? Часть первая
Эта история про OpenStack + KVM. Всё началось, когда работало всё хорошо. «Старая» платформа всех удовлетворяла. Её поднимали без нас, и она слегка устарела. Это была Juno. При этом она работала.
В принципе она была тестовой, пока в один прекрасный день не стала боевой. Мы знать не знали проблем, с которыми столкнулись потом. Начальство, радостно потирая руки, решило обновить парк систем. В том числе и тестовую платформу OpenStack.
Решили разворачивать вручную, поскольку в тот момент не было fuel решений под версию Mitaka. Поэтому развернули всё по рецептам c официального сайта. Конечно, немного добавили и от себя, например, заменили Memcached на Couchbase, а в качестве базы данных взяли percona в кластерном режиме. И всё шло хорошо. До определённого момента.
Cтали у нас пропадать пакеты. Сначала мы думали, что виноват коммутатор. На нём была Junos довольно старой версии — 11, которая имеет известные баги. И на консоли у неё действительно были сообщения, подтверждающие нашу догадку. Мы заменили это железо на другое, с новой, 15-й прошивкой Junos.
Между тем проблема не исчезла, а только стала потихоньку расширяться. Общий симптом выглядит так — пинги внезапно теряются. Постоянно обрывается связь.
Удручающе для нас и клиентов.
Есть у нас один клиент, много трафика потребляет. И генерирует в ответ тоже много. У него трансляции с веб-камер идут. Стал он жаловаться: пропадает связь и всё тут.
Вот что мы увидели на мониторинге:
Действительно — клиент прав, что-то не так. Но где??? В один из таких моментов мы нашли причину — не тот ARP светился в сети. Где же виновник? Виновный адрес был найден на выпускающем файрволе. Там стояла строчка, по-ошибке вписанная админом:
```
set security nat proxy-arp interface xxxx address yy.zz.tt.cc/32
```
Слава богу, нашли — была первая мысль. Но не тут-то было. Пропадание пакетов, не важно каких tcp, icmp, udp — продолжалось.
Мы продолжали искать, и стало ясно, что проблема где-то внутри OpenStack. Когда я стал пинговать тестовую виртуальную машину — чуть не упал со стула:
Это значило, что по какой-то причине часть пакетов не транслировалась, и вывалилась наружу с серыми адресами! Естественно, эти пакеты ни до кого не дошли.
Мы поделимся тем, что смогли раскопать, но позже. Хотелось бы увидеть мнение уважаемой публики, что мы делали не так и где надо было искать | https://habr.com/ru/post/321442/ | null | ru | null |
# Proof of Concept: Как проверить, что внедрение ML стоит свеч
Недавно в уютном чатике дата сатанистов подняли вопрос, как правильно "продавать" внутренние проекты по машинному обучению. Оказалось, что многие из нас весьма брезгливо относятся к экономическому обоснованию своей деятельности. Меж тем, чтобы провести минимальную оценку рентабельности проекта, никакого MBA не нужно — в небольшой статье (10 страниц текста, ке-ке-ке) я расскажу вам, что такое рентабельность инвестиций, как оценить её для внутреннего проекта, какую роль в этом играет Proof of Concept, и почему в реальной жизни всё может пойти не так. Делать мы всё это будем вокруг вымышленного проекта по автоматизации составления расписаний для колл-центра. Добро пожаловать под кат!
Наш вымышленный проект
----------------------
В колл-центре работает 100 операторов. Они работают по плавающему расписанию, выходя на работу сменами по 8 или 12 часов. Смены начинаются в разное время и расставлены так, чтобы обеспечивать дежурство множества людей в часы пик и малого количества людей в холодные часы по ночам и выходным. Расписание планирует дежурный супервайзер колл-центра темными пятничными вечерами, на глазок планируя нагрузку на следующую неделю.
Один 8-часовой день работы оператора колл-центра стоит компании 2.000 руб. Если считать, что в году 250 рабочих дней, то колл-центр обходится компании в `100 х 2.000 х 250 = 50 млн руб` в год. Если мы автоматизируем составление расписания, мы сможем прогнозировать почасовую нагрузку и расставлять смены так, чтобы варьировать число дежурных операторов в зависимости от прогнозной нагрузки. Если наш прогноз и расстановка смен окажется хотя бы на 10% лучше, чем прогноз и расстановка супервайзера, получится экономия аж 5 млн руб. в год. Если нам действительно удастся выжать 10% улучшения, проект однозначно окупится. Или нет?.. Давайте подумаем, как вообще принимать такие решения.
Как считают ROI
---------------
Прежде, чем начинать большой проект, неплохо бы оценить его экономическую целесообразность. Хрестоматийный способ сделать это — посчитать возврат на инвестиции, ROI.
ROI (Return on Investment) — это показатель доходности проекта, равный отношению доходов к затраченным инвестициям. ROI < 100% означает, что проект не окупится.
Первые расходы на проект случаются сразу, на старте — на закупку железа и лицензий, разработку системы и ее внедрение. Это называется капитальные расходы. По ходу жизни проекта на него тоже приходится нести расходы — на аренду того же железа и лицензий, поддержку работоспособности системы и, иногда, работу операторов. Это называется операционные расходы.
"Мгновенных доходов" у ML проектов, как правило, нет. Доходы у проекта только операционные, т.е. во времени. Например, в случае с нашим колл-центром, доход формируется как экономия расходов на операторов. Если операционные расходы проекта превышают доходы, проект не окупится никогда.
Из-за "мгновенных" капитальных расходов на старте проекта ROI будет зависеть от времени, на котором мы оцениваем доходность. Обычно для расчета ROI используется или год, или горизонт планирования, или время жизни системы. С годом все понятно — это простой способ понять, окупится проект за год или нет. Горизонт планирования — это временной интервал, на который планируется стратегия компании и составляются бюджеты. В малых и динамичных компаниях горизонт редко переваливает за год, в крупных и стабильных может составлять от трёх до десяти лет.
На далеком горизонте планирования можно окупить любой хлам, но на стражу здравого смысла встаёт время жизни системы. Обычно система через несколько лет перестаёт отвечать требованиям бизнеса, и её либо заменяют новой, либо выкидывают, либо (чаще всего) оставляют гнить на вечном саппорте. При быстром росте бизнеса система не всегда может прожить полгода, на устойчивом рынке система без доработок устаревает за 3-5 лет, а больше 10 может прожить только очень консервативная коробка в очень консервативной среде. Ставки дисконтирования, амортизацию и прочую бухгалтерскую магию оставим профессиональным финансистам.
Таким образом, расчет ROI делается по следующей формуле:
Proof Of Concept
----------------
Откуда мы вообще можем знать, что новое внедрение увеличит показатель на 10%?
Во-первых, мы можем выбрать это число наугад, вытрясти его из ближайшего авгура. Это часто работает, но не менее часто приводит к катастрофе. Такое вангование публично не поощряется, тем не менее, аксакалы признают, что многие успешные решения, на самом деле, были приняты "по чуйке".
Во-вторых, мы можем полагаться на опыт прошлых внедрений. Например, мы внедряем автоматизацию в пятый колл-центр подряд, до этого видели результаты в 7-10%, знаем и умеем решать все типовые проблемы, и кажется, нас ничто не должно подвести. Чем больше внедрений мы провели, тем точнее наш прогноз, и тем лучше мы понимаем влияние различных отклонений от идеала на результат.
Даже на опыте одного единственного внедрения можно сделать гораздо более осмысленный прогноз, чем на "чуйке". Смелое следствие из этого — кажется, что даже единственное незаконченное внедрение даст нам огромную фору перед "чуйкой". Так мы приходим к идее Proof of Concept, или PoC.
PoC нужен для того, чтобы подтвердить или опровергнуть работоспособность гипотезы, а также оценить её эффективность. PoC не предполагает завершенного внедрения, а значит, его можно провести быстро и дешево. Какие способы ускориться есть в Data Science проектах?
1. Взять данные вручную, грязно, напрямую из тех мест, откуда их проще всего анализировать. Даже если для продакшена этот источник будет не приемлем, это не важно.
2. Использовать самые тупые эвристики как бейзлайн. Например, бейзлайн для прогноза нагрузки на следующий день — нагрузка за сегодня. Еще круче — средняя нагрузка за последние 5-7-30 дней. Вы удивитесь, но такую эвристику не всегда удается превзойти.
3. Оценивать качество бек-тестированием — не проводить новых долгоиграющих экспериментов. Все данные уже есть в истории, оценим эффект по ним.
4. Не пытаться сделать переиспользуемый код. Весь код после PoC'а будет выброшен в ведро. Повторяем это каждое утро перед тем, как сесть кодить.
5. Не пытаться сделать крутую модель. Ставить себе жесткие дедлайны — один-три-пять дней на модель. За такие сроки не получится "закопаться" в сложную реализацию, зато получится перебрать много простых вариантов. По этим вариантам получится надежная оценка снизу.
6. Агрессивно искать грабли, наступать на все нелепые места, тестировать опасные идеи. Чем больше грабель мы соберем на этапе PoC, тем меньше рисков будет при продакшен разработке.
Этапы PoC
---------
Длительность PoC'а обычно варьируется от недели до пары месяцев. Над задачей будет работать один человек, ведущий дата сатанист. Проведение PoC'а требует также много внимания бизнес-заказчика — на разговоры в начале PoC'а и на осмысление результатов в конце. Итого, PoC будет стоить нам до двух месяцев работы ведущего DS и несколько дней работы бизнес-заказчиков. Вот и первый индикатор — если заказчик не нашел время на PoC, то и результат большого проекта не будет по-настоящему востребован.
Итак, этапы.
1. Перейти от "хотелок" и базз-вордов к конкретным бизнес-требованиям. Это традиционная задача бизнес-аналитика, но очень желательно, чтобы DS проводил её сам. Так он сможет точнее понять потребности заказчика и выполнить второй этап...
2. Сформулировать эксперимент. Правильная формулировка — залог успешности проекта. DS должен определить, в каком месте бизнес-процесса принимается автоматизированное решение, какая информация доступна на входе, что ожидается на выходе, к какой задаче машинного обучения это можно свести, какие данные потребуются при обучении и в продакшене, какие технические и бизнесовые метрики использовать для оценки успешности.
3. Разобраться с данными. DS должен понять, какие вообще данные нам доступны. Оценить их атрибутивный состав, полноту, глубину истории, непротиворечивость. Быстренько собрать вручную датасет, достаточный для построения модели и проверки гипотезы. Неплохо бы сразу осознать, будут ли данные в продакшене отличаться от того, что доступно в трейне, и что мы тут собрали.
4. Наинженерить фич и построить модель. Юные сатанисты с младых ногтей думают только о моделях (ЕВПОЧЯ), так что комментарии излишни.
5. Оценить качество модели. Правильно провести кросс-валидацию, посчитать технические и бизнесовые метрики, а также оценить пределы, в которых они могут колебаться в продакшене. Это все тоже должен делать DS.
6. Оценить полученный ROI — ради этого всё и затевается. Для оценки можно привлекать представителей заказчика и кого-то, кто умеет в фин. модели.
Проведем вымышленный PoC на основе нашего вымышленного проекта.
Этап 1. Перевод "хотелок" в задачу
----------------------------------
Вот формулировка "хотелки":
Кажется, если мы автоматизируем составление расписания, мы не только сэкономим время на планировании, но ещё и научимся варьировать число смен в зависимости от нагрузки.
Что это значит на самом деле?
Нужно сделать систему, которая по истории смен и обращений будет прогнозировать нагрузку на ближайший период, а также расставлять смены так, чтобы эффективно нагрузку утилизировать.
Метрика эффективности прогноза нагрузок — ошибка по числу обращений в квант времени.
Метрика эффективности утилизации нагрузки — 95ый перцентиль длительности ожидания.
Экономическая метрика — число смен за учетный период.
Задача развалилась на две — как прогнозировать нагрузку, и как расставить смены.
Во-первых, мы хотим прогнозировать число обращений на две недели вперед так, чтобы прогноз не оказывался ниже реальных значений больше чем на какой-то процент.
Во-вторых, мы хотим минимизировать число смен за период так, чтобы удержать 95ый перцентиль длительности ожидания в допустимых пределах, при том, что нагрузка будет как спрогнозировали.
Этап 2. Формулировка эксперимента
---------------------------------
### Задача 1. Прогнозирование нагрузки
В пятницу недели 1 мы хотим прогнозировать число обращений в каждый час недели 3. Результатом прогноза будет 168 чисел — по одному числу на каждый час следующей недели.
Интервал в неделю придется сделать, чтобы операторы успевали подстроиться под расписание.
Делать прогноз будем в пятницу днем — с одной стороны, это как можно ближе к целевым датам, с другой стороны, есть еще полдня, чтобы утрясти расписание вручную. Нам будут доступны исторические данные по обращениям за всю историю, а также календарь. Мы понастроим из этого много фич-агрегатов. Неплохо бы привязать нагрузку к нашим релизам, но таких данных на этапе PoC у нас не будет.
Сведем задачу к регрессии. Для каждого часа в истории будем строить feature-вектор и прогнозировать по нему нагрузку в этот час. Пусть метрикой успешности будет MAPE (или WAPE, по ходу разберемся). Кросс-валидироваться "в лоб" на временных данных нельзя — будем заглядывать в будущее. Обычный выход — разбить историю на пересекающиеся фолды со сдвигом в неделю (четыре недели?), и последнюю неделю считать контрольной. Критерий успешности — если наш WAPE (или кто там ещё?) удастся держать в рамках разумных границ. Над разумными границами, опять же, подумаем по ходу эксперимента.
### Задача 2. Расстановка смен
По спрогнозированной нагрузке хотим покрыть ее сменами так, чтобы число смен было минимальным, а показатели качества остались на приемлемом уровне.
На данный момент мы не расставляем операторов по календарю, мы только определяем, сколько смен в какой день поставить и с каким нахлёстом.
Расчет будет выполняться сразу после завершения прогноза нагрузки. Получается, что доступны все те же данные, плюс еще прогноз по нагрузке.
Похоже, что задачу удастся свести к обратной задаче о рюкзаке, т.н. [Bin Packing Problem](https://neerc.ifmo.ru/wiki/index.php?title=%D0%97%D0%B0%D0%B4%D0%B0%D1%87%D0%B0_%D0%BE_%D1%80%D1%8E%D0%BA%D0%B7%D0%B0%D0%BA%D0%B5#.D0.97.D0.B0.D0.B4.D0.B0.D1.87.D0.B0_.D0.BE.D0.B1_.D1.83.D0.BF.D0.B0.D0.BA.D0.BE.D0.B2.D0.BA.D0.B5). Это NP-полная задача, но есть алгоритмы ее субоптимального решения. Задачей эксперимента будет подтвердить или опровергнуть их применимость. Целевой метрикой будет число смен в комбинации, граничными условиями — средняя или максимальная длительность ожидания (или какой-то перцентиль). Длительность ожидания мы будем вынуждены моделировать как функцию от числа обращений и числа операторов в работе.
Этап 3. Изучим доступные данные
-------------------------------
Сходим к администраторам нашей CRM. Попинаем их немножечко, и они выгрузят нам список всех обращений в колл-центр за последние несколько лет. На самом деле, нас интересует, в первую очередь, сам факт обращения и время поступления. Если повезет, то мы сможем собрать данные о длительности звонка, идентификаторы операторов и клиентов. В более продвинутых колл-центрах, возможно, будет даже какая-то классификация обращений по темам и результатам, но это нам пока не понадобится.
Теперь сходим к супервайзеру колл-центра и попросим поднять все расписания операторов за несколько лет. Супервайзер переспросит нас пару раз, побледнеет, выпьет валидольчика — и через пару дней в наш почтовый ящик отфорвардят сотни писем с вложенными эксельками. Придется потратить еще дня три на то, чтобы свести всё это в одну большую таблицу со сменами. Для смены мы будем знать дату, время начала, длительность и идентификатор оператора.
Сразу подумаем, что, вероятно, чем больше у нас клиентов — тем больше нам звонят. Пригодится историческая информация о числе клиентов или объеме выпуска — так мы сможем учесть макро-тренды. Сходим еще раз к администраторам CRM или ERP и попросим у них выгрузку по объемам продаж, числу клиентов или типа того. Допустим, удалось раздобыть данные о подписках. Теперь сможем построить таблицу, где для каждой даты видно число активных клиентов.
Итого, у нас есть три сущности, удобно разложенные в три таблички:
* Обращение в колл-центр — номер, дата и время, длительность, идентификаторы клиента и оператора.
* Рабочая смена оператора — номер, дата, время начала, длительность, идентификатор оператора.
* Макро-тренд нагрузки — дата, число активных клиентов
Этап 4. Сгенерируем признаки и обучим модель
--------------------------------------------
Как помните, задача после декомпозиции развалилась на две. Вторую часть, про расстановку смен, мы сейчас трогать не будем — там не нужно машинное обучение. Поговорим про первую часть — прогнозирование нагрузки.
Эксперимент мы сформулировали как задачу регрессии — "для каждого часа в истории будем строить feature-вектор и прогнозировать по нему нагрузку в этот час". Давайте собирать обучающую выборку. Строкой в выборке будет календарный час. Каждому часу соответствует таргет — число обращений за этот час.
Теперь подумаем, какие признаки мы можем использовать.
1. Для начала, воспользуемся календарной природой наших данных. Добавим признаки дня недели, часа, дня месяца. Их можно [замкнуть в кольца](http://blog.davidkaleko.com/feature-engineering-cyclical-features.html).
2. Добавим число обращений в час по таким дням и в такие часы. Можно брать число обращений в последнюю неделю, а также среднее за месяц и за год.
3. Добавим аналогично число обращений в точно такой же час и день недели.
4. Возьмем окно агрегации пошире — добавим среднее число обращений в такой день недели и в такое время суток.
5. Попробуем сразу отнормировать числа обращений на тренд нагрузки. Протестируем как на нормированных, так и на сырых значениях.
6. Добавим сезонность — число обращений в месяц в прошлом году, нормированное на тренд нагрузки.
7. На всякий случай, добавим также "сырые" данные о тренде нагрузки. Причем возьмем как значение в текущий момент, так и "смещенные" значения — неделю назад, месяц назад.
Попробуем не только "обычную" функцию ошибки RMSE, но и [WAPE](https://en.wikipedia.org/wiki/Mean_absolute_percentage_error) — она больше подходит по смыслу задачи. Для валидации мы не сможем использовать обычную K-fold кросс-валидацию — появится шанс заглянуть в будущее. Поэтоиу будем использовать [Nested Folds](https://towardsdatascience.com/time-series-nested-cross-validation-76adba623eb9) разбиение, причем зафиксируем размер тестового фолда равным, скажем, 4-м неделям ровно. И границы фолдов будем устанавливать точно в полночь понедельника.
Для PoC'а попробуем две модели — линейную с L1 регуляризацией и самую любимую деревяшечку. Для линейной модели не забудем стандартизировать (и логарифмировать, где нужно) признаки, а для деревяшечки — выкрутить параметры регуляризации поагрессивнее.
Этапы 5 и 6. Оценим качество модели и экономический эффект
Итак, все приготовления завершены, и мы, наконец, можем перейти к самой интересной части PoC'а — анализу результатов и принятию решений.
К сожалению, весь пример был умозрительным, без реальных данных, так что и результаты будут высосаны из пальца. Чтобы не было так стыдно, я взял похожие по порядку цифры из книги "Call Center Optimization" за авторством Ger Koole (я нечаянно нашел ее, пока писал эту статью `¯\_(ツ)_/¯` ). Картинка оттуда же — на ней пример прогноза нагрузки.
Для начала, нам удалось предсказывать почасовую нагрузку с WAPE = 14%. Удалось достичь ошибки меньше 10% на 43% часов, меньше 20% на 70% часов.
Вообще, это очень неплохо — мы достаточно точно ловим и суточные колебания, и недельные циклы, и среднесрочные тренды. Обжигаемся только на случайных флуктуациях, и, скорее всего, избежать их не удастся.
По нагрузке мы сможем легко вычислить число операторов, которые должны быть в смене в данный час. Мы написали жадный неоптимальный алгоритм планировщика смен и вычислили, что что нам удается сэкономить 10% смен на прогнозной нагрузке. При этом оказалось, что если мы в дополнение к 12-часовым сменам введем 8-часовые и умно расставим их по суткам, можем сэкономить еще 5%.
Переводим показатели в деньги. Текущая стоимость годового содержания колл-центра — 50 млн руб в год. Наш эксперимент показал, что мы можем уменьшить эту сумму на 15%, что приведет к экономии до 7,5 млн руб в год, а за весь срок жизни — до 22,5 млн руб.
Это очень хороший эффект, и так и хочется признать PoC успешным. Давайте, однако, задержимся и проанализируем, что может пойти не так.
Риски, влияющие на экономический эффект
---------------------------------------
Мы получили положительный эффект за счет сокращения числа сотрудников. Число сотрудников мы смогли сократить за счет сокращения числа смен. Число смен мы смогли сократить за счет перераспределения их по предсказанной нагрузке. Нагрузку мы смогли предсказывать с помощью моделирования на основе исторических данных.
Во-первых, если паттерны пользования продуктами, которые обслуживает наш колл-центр, изменятся, исторические данные потеряют актуальность. Шанс того, что паттерны не изменятся в течение ближайших трех лет, достаточно мал. Нужно заложить расходы на дообучение и коррекцию модели по ходу ее жизни.
Во-вторых, мы предсказали нагрузку достаточно точно, но, тем не менее, в 30% случаев ошибаемся больше, чем на 20%. Может оказаться, что такая ошибка в час пик приводит к недопустимому росту длительности ожидания. Супервайзеры примут решение закладывать резервные смены для покрытия рисков.
В-третьих, при проведении PoC'а мы оперировали только сменами, а в реальности окажется, что на сменах работают вполне конкретные люди. Почему-то людей нельзя просто так увольнять и моментально набирать, а смены для сотрудника нужно ставить с учетом рабочего графика, Трудового Кодекса и личных пожеланий сотрудника. Из-за этих факторов придется держать штат чуть больше, чем того хочет машина.
Итого, нам нужно заложить резервные смены в часы пик и поддерживать немного "балласта" в тихие недели. А кроме того, нам нужно будет заложить расходы на поддержание модели.
Настало время поговорить о расходах и рисках, с ними связанных.
Разработка и сопровождение, их стоимость и риски
------------------------------------------------
По ходу проведения PoC нам стало понятно, что нужно делать для промышленной реализации решения.
Во-первых, нужно выстроить стабильно работающий процесс сбора данных. Оказалось, что мы достаточно легко можем получать данные из CRM. Однако, данные о расписании операторов мы были вынуждены собирать по крупицам. Значит, нам придется сначала сделать автоматизированную систему контроля расписаний операторов. Удачное совпадение, что результаты планирования мы тоже будем выгружать в эту систему. Мы оценили, что на разработку выгрузки из CRM у нас уйдет неделя-две. Разработка системы для управления расписанием потребует месяца два, и есть риск, что мы ошиблись в оценке в разы.
Во-вторых, нам нужно закодить сервис, применяющий модель для прогноза нагрузки, а потом закодить алгоритм, составляющий расписание под эту нагрузку. Саму модель мы уже обучили, как ее применять, примерно понятно — мы сможем упаковать ее в сервис примерно за неделю, максимум две. С алгоритмом составления расписаний сложнее, к тому же, мы можем погрязнуть в реализации ограничений или не смочь обойти комбинаторную сложность. Разработка алгоритма займет у нас от пары недель до двух-трех месяцев — неопределенность высока.
В-третьих, для работы всего этого потребуется инфраструктура — сервера приложений, базы, балансировщики и мониторинг. Как хорошо, что мы делаем это не в первый раз и знаем, что это займет где-то неделю. Если накосячим с оборудованием, то две. Сопровождение инфраструктуры будет занимать у нас от силы один-два человеко-дня в месяц, пфффф!.. Но за три года набежит до пары полных месяцев, ой. Кроме того, надо заложить дообучение и перевыкладку модели раз в полгода — итого 2-5 раз, каждый раз по 3-5 дней.
Просуммируем расходы в оптимистичном, реалистичном и пессимистичном вариантах.
Пусть средний разработчик обходится компании в 20 тыс. руб. в день.
Оптимистичный — 5 дней на CRM, 40 дней на систему управления расписанием, 5 дней на прогнозирование, 10 дней на составление расписаний, 5 дней на инфраструктуру, 3х12х0,5 дней на ее поддержку, и 2х3 дней на редкие дообучения модели. Итого 65 рабочих дня на разработку, 24 дня на поддержку. Итоговая стоимость решения — 1,3 млн руб на разработку + 0,48 млн руб на поддержку за 3 года.
Реалистичный — 10 + 60 + 10 + 20 + 10 + 3х12х1 + 5х3 = 110 разработки и 51 поддержки, 2,2 + 1,02 млн руб.
Пессимистичный — это когда все пошло не так. 20 + 80 + 20 + 40 + 10 + 3х12х2 + 5х5 = 170 разработки и 97 поддержки, 3,4 + 1,94 млн руб.
Отметим, что около 40% стоимости уходит на поддержку, как ни крути.
Оценка ROI и целесообразности проекта
-------------------------------------
При оптимистичной оценке мы получали 15% экономию на рабочей силе, что приводило нас к экономии 22,5 млн руб за срок жизни проекта, из которых 7,5 млн руб сваливалось на нас в первый год. Оптимистичная оценка расходов показывала всего 1,3 + 0,48 млн руб, что дает +6,2 млн (+377% ROI) в первый год и +21 млн руб (+1160% ROI) за время жизни. Божественно.
Однако, если реализуется хотя бы часть рисков, ситуация изменится. Если окажется, что на часы пик выпадает 50% смен, и мы захотим поддерживать 10%-ный резерв, мы тут же потеряем 5% эффекта. Еще 2,5% расходов на неэластичность штата — и вот мы потеряли в сумме 7,5% из 15% эффекта. Получаем всего 3,75 млн руб доходов в год, 11,25 млн за срок жизни. Это реалистичная оценка доходов.
Вычтем из этого расходы по реалистичной оценке — 2,2 млн на разработку и 1,02 на поддержку. Получим +55% ROI в первый год, +252% за срок жизни. Результат все равно достойный, но вывод о внедрении выглядит уже не таким однозначным.
Теперь давайте перестрахуемся и добавим 20%-ный резерв в часы пик. Мы потеряли еще 5% эффекта, осталось всего 2,5% сокращения расходов, или 1,25 млн в год, 3,75 млн за срок жизни. Это пессимистичная оценка эффекта, но эффект всё ещё хотя бы есть. Теперь при реалистичной оценке расходов проект не окупается в первый год, и только на горизонте в 3 года немного выходит в +17% ROI. Кажется, положить деньги на депозит выглядит надёжнее. Таким образом, при реалистичной оценке доходов и расходов мы уже не можем себе позволить 20%-ную перестраховку.
При реализации пессимистичного сценария разработки расходы составят 3,4 млн руб в первый год. Приемлемый ROI +121% мы получим только в самом радужном случае. На горизонте 3х лет также окупится с +108% ROI "средний" по доходам сценарий.
Таким образом, видно, что реалистично ждать от проекта ROI +55% в первый год и +252% за все время жизни, однако, мы будем вынуждены сильно ограничивать себя в резервах. И если мы не уверены в компетенциях собственной разработки, то проект лучше вообще не начинать.
| Сценарий дохода | Сценарий расхода | Income | Dev | Support | ROI 1г | ROI 3г |
| --- | --- | --- | --- | --- | --- | --- |
| Optim | Optim | 7,5 | 1,3 | 0,5 | +4x | +11x |
| Optim | Real | 7,5 | 2,2 | 1,0 | +2x | +6x |
| Optim | Pessim | 7,5 | 3,4 | 1,9 | +85% | +3x |
| Real | Optim | 3,75 | 1,3 | 0,5 | +155% | +5х |
| Real | Real | 3,75 | 2,2 | 1,0 | +48% | +2,5х |
| Real | Pessim | 3,75 | 3,4 | 1,9 | -7% | +112% |
| Pessim | Optim | 1,25 | 1,3 | 0,5 | -14% | +108% |
| Pessim | Real | 1,25 | 2,2 | 1,0 | -50% | +17% |
| Pessim | Pessim | 1,25 | 3,4 | 1,9 | -69% | -29% |
P.S. Делать свое или купить готовое
-----------------------------------
Живой менеджер изучил бы альтернативные решения еще до внедрения PoC, но у нас же умозрительный проект, да? К тому же, про сторонние закрытые решения статью не напишешь...
Существуют десятки решений для управления колл-центром, они состоят из кучи модулей, и многие из них содержат модуль WFM, WorkForce Management. Он делает как раз то, что мы описали — составляет расписание, а иногда даже предиктит. Обычно решение для колл-центра продается всё целиком, и софт, и железо. Рабочее место целиком стоит от $1000 до $2500. Модули WFM ставятся или сразу до кучи, или потом вдогонку. Таким образом, в реальной жизни менеджер пошел бы за WFM решением к вендору своего колл-центра. Давайте же немного порассуждаем, а есть ли вообще смысл делать кастомное решение?
Для начала, есть очень важный стоп фактор — каким будет исход разработки, сильно зависит от компетенций компании. Если компания не уверена в своих разработчиках и DS'ах, вероятность пессимистичного исхода слишком велика. В этом случае нужно однозначно использовать решение от вендора. Просто исходя из этого соображения, просто по этому пути идут все нетехнологические компании. Технологические компании отличаются тем, что сила их команды даёт шансы на оптимистичный исход. Вот тут начинается математика.
Решения от вендоров биллятся, исходя из стоимости аренды рабочего места. По нашей "реалистичной" оценке дохода в 7,5%, мы экономим на одном рабочем месте 37,5 тыс. руб в год. Это и есть максимальная стоимость решения. Если решение стоит дешевле — оно принесет положительный ROI. С собственной разработкой все сложнее — окупаемость зависит от числа операторов. За первый год положительный ROI возможен при расходах на операторов в 26,66 млн в год, что достигается при 53 операторах. За три года положительный ROI начинается от 27 операторов.
При выборе стороннего решения кроме простой математики стоит учесть еще два фактора.
Во-первых, это риски. При покупке решения вы получите что-то более-менее работающее. При реализации решения своими силами у вас остается существенный шанс провала.
Во-вторых, это активы. По окончании разработки вы получаете актив, который можете развивать и дорабатывать. При аренде или покупке лицензии собственного актива вы не получаете.
Что из этого важно — решать вам.
Выводы
------
1. Готовый WFM уже есть в любом приличном провайдере колл-центров. Скорее всего, вы собирали колл-центр не с нуля. Взять модуль WFM у вашего вендора — самое лучшее решение.
2. Если у вас нет проверенной команды разработчиков и дата сатанистов — не надо делать своего решения.
3. Если вы сильны и там, и тут, то ~~зачем вы вообще читаете эту статью?~~ всё равно не спешите бросаться в бой, а сначала проверьте жизнеспособность идеи с помощью PoC'а.
4. Добавьте к результатам PoC'а побольше безысходности и пессимизма и честно посчитайте, а стоит ли оно того?
5. Если и это вас не остановило — ждите продолжение истории на [телеграм-канале автора](https://t.me/fediqs). | https://habr.com/ru/post/438212/ | null | ru | null |
# Меши с Python & Blender: двумерная сетка
Привет! Понадобилось процедурно генерировать сложную модель, и пока я копал, как это делается, нашёл несколько статей от Diego Gangl, cg артиста и разработчика Блендера. Они славные для новичка, понимающего в моделировании, и не умеющего в код. Это перевод одной из них. Неточности и ошибки автора я поместил под спойлеры.
Процедурная генерация мешей даёт уйму возможностей. Можно сделать модель, чьё состояние зависит от событий в реальном мире, заняться генеративным артом, моделировать формы, основанные на матфункциях, или даже создавать контент для игр. Блендер — прекрасный выбор инструмента. Это комбайн для моделирования и анимации, и у него есть жирный и хорошо документированный Python API.
Важная заметка: сохраняйтесь чаще, особенно ковыряясь со скриптами!
Начнём-с
--------
Меш и объект для Блендера — разные вещи. Взаимосвязь такая: создаём меш → привязываем к объекту → привязываем объект к сцене.
Стартанём с импорта bpy и пары переменных.
```
import bpy
# Настройки
name = 'Gridtastic'
rows = 5
columns = 10
```
Переменная `name` используется и для объекта, и для меша. Переменные `rows` и `columns` будут определять координаты вертексов меша. Дальше настроим добавление меша и объекта. Создадим меш, потом объект с привязкой к нему меша , потом привяжем объект к сцене. Сразу создадим пустышки для вертексов и полигонов, и чуть позже накидаем в них данных.
```
verts = []
faces = []
# Создаём меш
mesh = bpy.data.meshes.new(name)
mesh.from_pydata(verts, [], faces)
# Создаём объект и привязываем к сцене
obj = bpy.data.objects.new(name, mesh)
bpy.scene.collection.objects.link(obj)
# Выделяем объект
bpy.context.view_layer.objects.active = obj
obj.select = True
```
...если бездумно копипастнутьничего не произойдёт, кроме печального AttributeError: module 'bpy' has no attribute 'scene'. Опечатка автора статьи в том, что строка привязки должна выглядеть так: bpy.context.scene.collection.objects.link(obj)
Кроме того, выделение объекта в версиях старше 2.79 реализовано так: obj.select\_set(True)
Наиболее интересна функция `from_pydata()`. Она и создаёт меш, исходя из трёх списков: вершин, рёбер и граней. Подробнее об этой функции в [родной документации](https://docs.blender.org/api/2.77/bpy.types.Mesh.html#bpy.types.Mesh.from_pydata).
Сетка из вершин
---------------
Резонно начать с первого вертекса. Каждый вертекс описывается тремя координатами: по X, Y, Z осям. Поскольку мы делаем двумерную сетку, координата Z будет всегда равна нулю. Первый вертекс расположим в нулевых координатах сцены, они же нули глобальных координат. Иначе говоря, в координатах (0, 0, 0). По сути, вертекс это кортеж из трёх чисел с плавающей точкой. Перепишем список с вертексами таким образом:
```
verts = [(0, 0, 0)]
```
Попробуйте запустить скрипт, и вы увидите одинокую точку. Она даже редактируема. Пора сделать ряд точечек. Нам потребуется цикл, накидывающий столько вершин, сколько колонок мы обозначили.
```
verts = [(x, 0, 0) for x in range(columns)]
```
Поскольку `range()` возвращает целые числа, кооордината X каждой вершины будет по сути номером колонки. Что означает, что ширина колонки равна одному блендер-юниту. Снова прогнав скрипт, мы увидим десять вертексов в ряд. До сетки из вертексов осталась капля: добавить строчки. Сделаем их так же циклом:
```
verts = [(x, y, 0) for x in range(columns) for y in range(rows)]
```
Победа! Налицо сетка из вертексов.
Пора создать полигоны, но сначала осознаем, как это работает.
Полигон
-------
У каждого вертекса есть индекс. Как только рождается новая вершинка, так ей тут же присваивают порядковый номер. Но самая первая будет с индексом 0.
Полигон — кортеж из индексов вертексов. Для формирования полигона их может быть от трёх до бесконечности. Кроме того, эти индексы — натуральные числа. Если вставить дробное значение, Блендер не крашнется, но округлит его. Ну, а поскольку мы хотим четырёхугольные полигоны, для каждого полигона нам потребуется четыре индекса вертексов. Каких? Ну, можно прикинуть на глаз, но есть более клёвый вариант: включить режим отладки. Откройте питон-консоль Блендера, и вбейте туда команду:
примечание про версии БлендеровКод ниже — для Блендра *до* версии 2.8. Ежели у вас Блендер в диапазоне 2.8-3, нужная галочка лежит тут: Edit → Preferences → Interface → Display → Developer Extras. Теперь во Viewport Displays (в Edit Mode) появится чекбокс Indices.
```
bpy.app.debug = True
```
Я надеюсь, что если вы и почерпнёте что-то из этого туториала, то это будет режим отладки. Это лучшее, что может с вами произойти, пока вы пишете скрипт или даже пилите аддон. Для просмотра индексов вершин свежесозданной сетки, перейдите в режим редактирования объекта и выделите нужную вершину. В N-панели во вкладке Mesh Display Panel поставьте галочку на Indices, чекбокс появится в колонке Edge Info. Если этого чекбокса нет, вероятно, режим отладки выключен. Теперь все выделенные вершины будут показывать свои индексы.
Сосредоточимся на первом полигоне. Его образуют вертексы с индексами 0, 1, 5 и 6. Попробуем:
```
faces = [(0, 1, 5, 6)]
```
Запускаем скрипт, и видим странную картину: как будто бы мы соединили неправильные вертексы.
На самом деле вертексы правильные, но порядок записи некорректен. Дело в том, что индексы в кортеже должны располагаться начиная с нижнего левого угла, и против часовой стрелки:
примечания про порядок обхода вершинПервое: абсолютно неважно, с какой вершины начнётся обход, лишь бы по кругу.
Второе: обход по часовой или против часовой влияет на направление нормали полигона, но никак не влияет на его построение.
То есть на самом деле нужна была такая последовательность: 0, 5, 6, 1. Исправим строчку кода, и снова запустим скрипт:
Вот теперь хорошечно. Когда возникают такие проблемы, попробуйте поменять местами индексы в первой или второй паре. А теперь веселье: надо понять, как составить список вершин для ряда из полигонов. Если присмотреться, увидим такую закономерность:
* все индексы прибавляют по пять пять по оси X
* первый индекс равен нулю, второй на единицу больше
Первый индекс каждого полигона — номер столбца, умноженный на количество колонок. Второй смещается на единицу относительно первого, так что просто добавим её. Накидаем код и проверим выхлоп:
```
for x in range(columns - 1):
print(x * rows)
print((x + 1) * rows)
```
Почему у количества колонок отнимается единица? Потому что на десять вертексов приходится девять рёбер, то есть нам нужно девять пар чисел.
Третий и четвертый индексы будут равны `(x + 1) * rows + 1` и `x * rows + 1` соответственно. Добавим единицу к X перед умножением, чтобы сместить индекс во вторую строчку.
Цикл, который выведет наборы индексов для каждого полигона в строке:
```
for x in range(columns - 1):
print('first:', x * rows)
print('second:', (x + 1) * rows)
print('third:', (x + 1) * rows + 1)
print('fourth:', x * rows + 1)
print('---')
```
Делаем меш
----------
Со всеми этими знаниями мы можем приступить к созданию первого ряда полигонов. Но прежде завернём кусок кода для полигонов в функцию, для большего удобства и читаемости. Кроме того, я докинул создание полигонов построчно. На каждый следующий ряд индексы возрастают на единицу, так что просто добавляем номер ряда в конце.
```
def face(column, row):
""" Создаём полигон """
return (column* rows + row,
(column + 1) * rows + row,
(column + 1) * rows + 1 + row,
column * rows + 1 + row)
```
Добавим в код полигонов эту функцию, как мы сделали это с кодом вертексов:
```
faces = [face(x, y) for x in range(columns - 1) for y in range(rows - 1)]
```
Отнимаем у количетсва строк единицу по тем же причинам, что и отнимали у колонок. Запустим скрипт и возрадуемся.
Вот и всё! Только что вы своими руками написали скрипт, генерирующий двумерную сетку. Дальше ещё немного хитростей.
Масштабирование
---------------
Мы можем регулировать количество вертексов, составляющих сетку, но размер ячейки всегда будет равен одному блендер-юниту. Поправим же это.
Достаточно простого умножения координат на число, определяющее масштаб. Добавим переменную для этого числа. Можно вписать её прям к вертексам, но будет лучше сделать отдельную функцию.
```
size = 1
def vert(column, row):
""" Создаём точку """
return (column * size, row * size, 0)
verts = [vert(x, y) for x in range(columns) for y in range(rows)]
```
Попробуем поменять значение `size` на что-нибудь другое, и посмотрим, что получится.
bu: blender unitФинальный код
-------------
```
import bpy
# Настройки
name = 'Gridtastic'
rows = 5
columns = 10
size = 1
# Функции
def vert(column, row):
""" Создаём точку """
return (column * size, row * size, 0)
def face(column, row):
""" Создаём полигон """
return (column* rows + row,
(column + 1) * rows + row,
(column + 1) * rows + 1 + row,
column * rows + 1 + row)
# Циклы для списка координат и вертексов
verts = [vert(x, y) for x in range(columns) for y in range(rows)]
faces = [face(x, y) for x in range(columns - 1) for y in range(rows - 1)]
# Создаём меш
mesh = bpy.data.meshes.new(name)
mesh.from_pydata(verts, [], faces)
# Создаём объект и привязвыем к сцене
obj = bpy.data.objects.new(name, mesh)
bpy.context.scene.collection.objects.link(obj)
# Выделяем объект
bpy.context.view_layer.objects.active = obj
obj.select = True
```
Заключение
----------
Надеюсь, вам понравилось! Это самый простой пример создания меша, что я смог придумать, и дальше ещё много интересных штук, которые можно сделать. Вот несколько несложных вещей, на которых вы можете потренироваться:
* разбить коэффициент масштабирования по осям;
* добавить сетке смещение, чтобы она начиналась не в нулевых координатах;
* красиво запаковать это в функции (или классы)
В следующем туториале перепрыгнем в трёхмерное пространство и сделаем куб.
---
[Оригинал статьи](http://sinestesia.co/blog/tutorials/python-2d-grid/) (автор не прикрутил к сайту сертификат, браузер может ругаться.)
* [Меши с Python & Blender: кубы и матрицы](https://habr.com/ru/post/647063/)
* [Меши с Python & Blender: икосферы](https://habr.com/ru/post/647193/)
* Меши с Python & Blender: скруглённый куб
* Меши с Python & Blender: круги и цилиндры
[Настройка Blender 3D для работы со скриптами](https://habr.com/ru/post/647195/) | https://habr.com/ru/post/646527/ | null | ru | null |
# Обобщаем анимацию таблиц в iOS приложениях
#### Пользователи хотят видеть изменения
Анимированное обновление списков всегда было непростой задачей в iOS. Что неприятно, это всегда было рутинной задачей.
Приложения крупных компаний, таких как Facebook, Twitter, Instagram, VK, используют таблицы. Более того, почти каждое iOS приложение написано с использованием UITableView или UICollectionView и пользователи хотят видеть, что изменяется у них на экранах, по этой причине reloadData не подходит для обновления экрана. Посмотрев несколько уже имеющихся фреймворков для данной задачи, я удивился, как много они в себе обобщают, помимо расчета анимаций. Некоторые же вообще при вставке одного элемента в начало, радостно сообщали о перемещениях всех остальных элементов.
Начав решать проблему обобщения построения и запуска анимаций, я ещё не понимал такого количества наличия подводных камней в дебрях UIKit. Но обо всём по порядку.
### Рассчёт изменений
Чтобы попытаться анимировать таблицу, нужно для начала вычислить, что изменилось в двух списках. Есть 4 типа изменений ячейки: добавление, удаление, обновление и перемещение. Добавление и удаление рассчитать довольно просто, можно взять два вычитания списков. Если элемента нет в исходном списке, но есть в новом, то он был добавлен, а если же он есть в исходном, но нет в новом, то его удалили.
```
var initialList: Set = [1,2,3,5,6,7]
var resultList: Set = [1,3,4,5,6]
let insertList = resultList.subtracting(initialList) // {4}
let deleteList = initialList.subtracting(resultList) // {7, 2}
```
С обновлением ячейки немного сложнее. Сравнения ячеек оказывается недостаточно для определения обновления ячейки и приходится возлагать это на пользователя. Для этого заводится поле *updateField*, в которое пользователь отдаёт признак актуальности ячейки. Это может быть *Date* (Timestamp), какой-то целочисленный или строковый хэш (К примеру, новый текст изменённого сообщения). В общем, это сумма полей, которые отрисовываются на экране.
С перемещением ситуация схожа, но немного другая. Теоретически мы можем, сравнивая поля, узнать, что одно переместилось относительно другого, но на практике происходит следующее:
Например, есть два массива,
```
let a = [1,2,3,4]
let b = [4,1,2,3]
```
Быстро бросив взгляд на список, сразу видно, что «4» поменяла свою позицию и передвинулась влево, но на самом деле могло произойти так, что «1», «2» и «3» передвинулись вправо, а «4» осталась на месте. Результат один и тот же, а способы совершенно разные, причём разные не только логически, но и визуально анимация для пользователя будет разной. Однако, нельзя, имея на руках только способ сравнения элементов, стопроцентно сказать, что именно передвинулось.
Но что если мы введём утверждение, что элементы перемещаются только вверх? Тогда становится понятным, **что** именно переместилось. Поэтому предоставлена возможность выбирать приоритетное направление расчета перемещений. К примеру, при написании мессенджера, какой-то определённый чат скорее всего переедет снизу вверх при добавлении нового сообщения. Однако, можно предоставить функцию для индикации о перемещении ячейки. Предположим, во вью модели есть поле *lastMessageDate*, которое изменяется при новом сообщении и, соответственно, изменяется порядок сортировки данной вью модели относительно других.
В итоге мы вычислили все 4 типа изменений. Дело за малым — применить их.
### Применение изменений к таблицу
Для того, чтобы запустить изменения в таблице, в UITableView и UICollectionView предусмотрены специальные механизмы изменений, поэтому просто воспользуемся стандартными функциями.
```
tableView.beginUpdates()
self.currentList = newList
tableView.reloadRows(animations.toUpdate, with: .fade)
tableView.insertRows(at: animations.toInsert, with: .fade)
tableView.deleteRows(at: animations.toDelete, with: .fade)
tableView.reloadRows(at: animations.toUpdate, with: .fade)
for (from, to) in animations.cells.toMove {
tableView.moveRow(at: from, to: to)
}
tableView.endUpdates()
```
Запускаем, проверяем, всё отлично, всё работает. Но только до поры до времени…
Когда мы пытаемся обновить и переместить ячейку, мы падаем с ошибкой: *attempt to delete and reload the same index path*
Первая мысль, которая приходит в голову: “Но я же не пытаюсь удалить ячейку!”. На самом деле *move* и *update* является ни чем иным как *delete* + *insert*, а таблица очень не любит таких действий и бросает ошибку (Всегда удивлялся, почему бы *try-catch* не сделать уже). Лечится она просто, выносим обновления в следующий цикл.
```
tableView.beginUpdates()
// insertions, deletions, moves…
tableView.endUpdates()
tableView.beginUpdates()
tableView.reloadRows(animations.cells.toDeferredUpdate, with: .fade)
tableView.endUpdates()
```
Теперь переходим к одной из самых сложных проблем, которую пришлось решить.
Всё вроде бы работает прекрасно, но при обновлении ячейки видно странное “моргание”, причём не зависимо от того, передаётся стиль анимации .fade или .none, хоть это и не логично.
Вроде бы мелочь, но при наличии приличного количества обновлений в таблице, начинает отвратительно «перемаргивать», чего очень не хочется. Чтобы всё это обойти, приходится синхронизировать между собой анимации вставки-удаления-перемещения и обновления. То есть, пока не закончится первый *.endUpdates()*, нельзя начинать новый *.beginUpdates()*. Из-за этой, вроде бы незначительной проблемы пришлось написать класс синхронизации анимаций, который всё это дело обрабатывает. Единственным минусом стало то, что теперь изменения применяются не синхронно, а отложенно, то есть они ставятся в последовательную очередь.
**Код синхроназции анимаций с помощью DispatchSemaphore**
```
let operation = BlockOperation()
// 1. Синхронизируем анимации. Нельзя использовать семафоры на главном потоке, так что ожидаем завершение анимации в специальной стерилизованной очереди
operation.addExecutionBlock {
// 2. Получаем текущий список. Он не передаётся явно, а получается непосредственно перед рассчётом анимаций
// потому что может быть изменён предыдущей задачей в очереди
guard let currentList = DispatchQueue.main.sync(execute: getCurrentListBlock) else { return }
do {
// 3. Просим рассчитать анимации
let animations = try animator.buildAnimations(from: currentList, to: newList)
var didSetNewList = false
DispatchQueue.main.sync {
// 4. Применяем анимации вставки, удаления и перемещения
mainPerform(self.semaphore, animations)
}
// 5. Ждём завершения анимации
_ = self.semaphore.wait()
if !animations.cells.toDeferredUpdate.isEmpty {
// 6. Происходит то же самое, только для отложенной update операции
DispatchQueue.main.sync {
deferredPerform(self.semaphore, animations.cells.toDeferredUpdate)
}
_ = self.semaphore.wait()
}
} catch {
DispatchQueue.main.sync {
onAnimationsError(error)
}
}
}
self.applyQueue.addOperation(operation)
```
Внутри *mainPerform* и *deferredPerform* происходит следующее:
```
table.performBatchUpdates({
// insert, delete, move...
}, completion: { _ in
semaphore.signal()
})
```
Наконец, завершив задумку, я поверил, что знаю всё об аномалиях, пока не наткнулся на странный баг, повторяющийся не всегда, но на определённых наборах изменений, когда применяешь обновления вместе с перемещениями. Даже если обновление и перемещение абсолютно никак не пересекаются, таблица может бросить фатальное исключение, и я окончательно удостоверился, что это никак не разрешить, кроме выноса *reload* в следующий цикл применения анимаций. “Но ведь можно просить ячейку у таблицы и насильно обновлять у неё данные”, скажете вы. Можно, но только в том случае, когда высота ячеек статична, ведь её пересчёт нельзя просто так вызвать.
Позже возникла другая проблема. С AppStore стали часто прилетать ошибки падения таблицы. Благодаря логам, определить проблему было нетрудно. В функцию расчёта анимаций передавали невалидные списки вида:
```
let a = [1,2,3]
let b = [1,2,3,3,4,5]
```
То есть, одинаковые элементы задублировались. Лечится это довольно просто, аниматор стал бросать ошибку при расчете (Обратите внимание на листинг выше, там как раз расчет обёрнут в *try-catch* блок, как раз по этой причине). Определяя неконсистентность, с помощью сравнения количества элементов в исходном массиве (Array) и наборе элементов (Set). При добавлении элемента в Set, в котором он уже есть, он заменяется, и поэтому элементов в Set отказывается меньше, чем в массиве. Данную проверку можно отключить, но делать это очень не рекомендуется. Поверьте, в очень многих местах это спасло от ошибки, несмотря на уверенность разработчиков в правильности передаваемых аргументов.
### Заключение
Анимировать таблицы в iOS не так просто. Большу́ю часть сложности добавляют закрытые исходники UIKit, в которых невозможно всегда понять, в каких случаях он бросает ошибку. Документация Apple по данному вопросу крайне скудна и говорит лишь, относительно индексов какого списка (старого или нового) необходимо передавать изменения. Способ работы с секциями таблиц ничем не отличается от работы с ячейками, поэтому примеры показаны только на ячейках. В статье код упрощён для более лёгкого понимания и уменьшения размера.
Исходный код находятся на [GitHub](https://github.com/Nekitosss/TableAnimator), можно подцепить с помощью [cocoapods](https://cocoapods.org/pods/NPTableAnimator) или с помощью исходного кода. Код протестирован на множестве кейсов и в текущий момент живёт в продакшене некоторых приложений.
Совместим с iOS 8+ и Swift 4
#### Используемый материал
[Документация Apple по .endUpdates](https://developer.apple.com/documentation/uikit/uitableview/1614890-endupdates)
[Применение изменений в iOS 11](https://developer.apple.com/documentation/uikit/uitableview/2887515-performbatchupdates) | https://habr.com/ru/post/350230/ | null | ru | null |
# Мультиклеточный процессор — это что?
Многие слышали о мультиклеточной архитектуре, процессорах и даже первых устройствах на них. Особенно продвинутые пользователи опробовали свои алгоритмы. Были проведены первые простые тесты производительности, а также пользователь [Barsmonster](http://habrahabr.ru/users/barsmonster/), вытравил кристалл процессора Р1. Сейчас уже проходит первые проверки процессор R1 и скоро будет доступен всем. Но ответ на вопрос о том, как работает мультиклеточная архитектура и в чём её отличие, знают не все. Попытаемся сейчас ввести в курс дела.
**1.Мультиклеточность**
**Мультиклеточное ядро** — это группа идентичных процессорных блоков(2 и более), объединенных полносвязной однонаправленной коммутационной средой. Особенности взаимодействия процессорных блоков между собой вытекают из представления алгоритма (об этом ниже). Процессорный блок в мультиклеточной архитектуре называется клеткой. Набор команд, который она может выполнять определяется конкретной реализацией и не зависит от архитектуры.
**Алгоритмы «глазами» мультиклеточного ядра
Во-первых.**
Любую формулу можно представить в виде ярусно-параллельной формы (ЯПФ). Рассмотрим
простой пример: g = e\*(a+b) + (a-c)\*f, в ЯПФ это может выглядеть так:
Рис 1. Пример ЯПФ
В общем случае, для выполнения операций узлы, расположенные на i-ом ярусе, могут использовать результаты, полученные на ярусах от 1 до (i-1)-го. Из этого следует, что команды, находящиеся на одном ярусе, независимы.
Любой алгоритм – это множество формул, которое разделено на подмножества — линейные участки, связанные между собой операторами передачи управления. Под линейным участком (ЛУ) понимается такое подмножество формул, которое вычисляется тогда и только тогда, когда управление передано на данный линейный участок. Внутри линейного участка, информационно несвязанные формулы могут выполняться в любом порядке.
Как известно, результат выполнения процессором любой команды выражается в изменении состояния процессора. Использование этого нового состояния последующими командами, образует информационную связь между командой–источником результата и командами–приемниками этого результата. Такая связь может быть как опосредованной (косвенной), так и непосредственной (прямой).
При косвенной связи результат доступен только после его отчуждения: записи в общедоступные регистры или память или др. устройства. Команда-источник должна поместить результат в эти устройства, а команда-приемник должна будет взять данные оттуда. Имя устройства указывается в качестве операнда. Такая связь между командами является основой абсолютно всех современных процессоров, кроме мультиклеточных.
В случае прямой информационной связи, команды именуются и при этом имена должны идентифицировать собственно команду, а не ее местоположение или другие особенности реализации. Доступ к результатам может осуществляться по именам как команд–источников, так команд–приемников. В первом случае используется широковещательная рассылка с последующим поименным отбором, при которой в поле операнда команды–приемника задают имя команды–источника. Во втором – выполняется поименная рассылка, при которой в команде–источнике задают имя команды–приемника результата.
Теоретически узлы ЯПФ мы можем поименовать любым образом. Единственное требование — однозначность. Для этого в мультиклеточном процессоре команды, при выборке из памяти, получают тег (метку) — таким образом им и их результатам дается локальное имя — и далее взаимодействие между командами организовывается через теги. Данные можно получать из любой команды с тегом меньше своего. Номер тега требуемого результата задается разницей значений тега команды и тега требуемого результата. Например, если в операнде указано @5, а тег команды равен 7, то в качестве операнда используется результат команды с тегом 2. Все результаты выполнения команд поступают в коммутационную среду, из которой по тегу отбираются требуемые. Таким образом в мультиклеточном процессоре используется широковещательная рассылка результатов с последующим их поименным отбором.
*Стоит отметить, что из-за физических ограничений есть понятие «окна видимости», которое определяет максимальное расстояние команды-источника от команды приемника. Тег в процессе выборки команд изменяется циклически. Его максимальная величина определяется размером буфера команд. Фактически размер тега определяет количество команд, которые одновременно могут находиться на разных стадиях исполнения. Значение тега не может быть использовано, если команда, которой он ранее был присвоен, еще не выполнена.*
**Во-вторых.**
Мультиклеточный процессор оперирует структурами, которые мы называем — параграфами.
**Параграф** — это информационно замкнутая последовательность команд. Параграф является аналогом команды, после выполнения которой, изменяется состояние процессора и/или систем в его составе (регистров, шин, ячеек памяти, каналов ввода/вывода и т.д.). Т.е. для мультиклеточного ядра параграф — это команда.
**Основная особенность мультиклеточной архитектуры** в том, что она непосредственно реализует ЯПФ представления алгоритма. Из такого понимания алгоритма вытекают многие свойства мультиклеточной архитектуры.
**2.Свойства мультиклеточной архитектуры**
* независимость от кол-ва клеток;
* динамическое распределение вычислительных ресурсов;
* все команды, готовые к выполнению, выполняются одновременно;
* снижение энергопотребления. Работает тогда, когда есть работа;
* масштабируемость, нет ограничений на кол-во клеток.
Рассмотрим подробнее как будет выглядеть параграф для алгоритма, описанного в п.2.
Для мультиклеточно ядра характерна следующая схема построения параграфа (не является обязательной, в приведенном примере так же есть отступления):
* получение данных для работы (команды с тегом 0-2,4,6 в примере);
* процесс обработки данных (команды с тегом 3,5,7-9 в примере);
* сохранение результатов (команда с тегом 10 в примере).
Следует напомнить, что изменение состояния машины в мультиклеточном процессоре происходит по концу параграфа.
**Алгоритм не зависит от кол-ва клеток.**
Информационные связи между командами указаны явно и нет необходимости знать о количестве процессорных блоков, когда пишется программа. Команды просто ждут готовности своих операндов и после этого уходят на исполнение и им не важно кто и когда им подготовит операнды. Представьте лейку — вы не задумываетесь сколько отверстий в ее насадке, когда поливаете. Клетки идентичны и нет разницы в какой клетке будет выполняться та или иная команда.
Команды распределяются по клеткам в порядке их следования, 1 команда в 0 клетку, 2 команда в 1 клетку и т. д., когда передали команду в последнюю имеющуюся клетку — начинаем распределять заново с 0 клетки. Рассмотрим работу 4-х клеточного ядра. Параграф, приведенный выше, будет выполняться следующим образом:
Рис 2. Распределение команд по клеткам
*Кол-во одновременно выполняемых команд зависит от кол-ва клеток. Выбор оптимального числа клеток для каждой задачи — это задача, которая требует анализа. Создать универсальную систему все равно не получится, поэтому можно ориентироваться на следующие данные: на общих задачах неплохо справляются 4 клетки, а с задачами обработки сигналов — 16 клеток, а для обработки видеоизображения их число может быть порядка сотен.
Можете провести анализ своего кода и представить каким было бы оптимальное число клеток для них. Для того потребуется представить ваш алгоритм в ЯПФ и подсчитать количество команд в ярусах. Среднее число команд в них будет намекать на оптимальное количество клеток в вашем конкретном случае.*
**Все команды, готовые к выполнению, выполняются одновременно.**
*Как упоминалось выше, мультиклеточное ядро реализует ЯПФ представление алгоритма, на ярусах располагаются независимые команды.* Все, что в данный момент может быть выполнено — будет выполнено без каких-либо специальных указаний со стороны программиста, основное условие — команда должна получить все данные для исполнения.
Стоит учитывать технологические ограничения: кол-во клеток ограничено, поэтому выполняться одновременно будет столько команд, сколько клеток в ядре.
**«Сход-развал» или динамическое распределение вычислительных ресурсов**
Т.к. код не зависит от количества клеток, которым он будет исполняться, появляется способность мультиклеточного ядра к распределению своих вычислительных ресурсов во время работы, при этом управление происходит программно.
Способность мультиклеточной архитектуры перераспределять свои ресурсы мы называем — **реконфигурацией**. Например, клетки мультиклеточного ядра могут быть, как угодно распределены для выполнения какого-либо алгоритма или его части. Группа (лучше названия пока не придумали) — это часть клеток мультиклеточного ядра, которые связаны между собой для выполнения какого-либо алгоритма или части алгоритма. В группе может находиться 1 и более клеток. Когда мультиклеточное ядро разделяет группу на части — это называется **декомпозиция**. Процесс объединения в группу — **композиция**. На рис 3 ниже показано как 4-х клеточное ядро со временем реконфигурируется (пример). Клетки, выполняющие одну задачу, имеют одно цветовое заполнение.
Рис 3. Пример реконфигурации клеток
**Снижение энергопотребления. Работает тогда, когда есть работа.**
Принципиальной основой мультиклеточной архитектуры является широковещательная рассылка. На сегодняшний день – это пока единственная архитектура, использующая непосредственную информационную связь для передачи данных между командами в программе.
Если обратить внимание на рис 1, на котором показан пример выполнения кода 4-х клеточным процессором, то видно, что клетки выполняют команды расположенные на ярусах тогда, когда они готовы быть выполнены. Результат помещается в коммутационную среду и ждет своего потребителя.
Мультиклеточное ядро не совершает лишних действий, работает тогда, когда есть работа. Если какая-нибудь из составляющих процессора не готовая выполнить команду, то работа с ней приостанавливается до освобождения.
**Масштабируемость, нет ограничений на кол-во клеток.**
Архитектура не ограничивает кол-во клеток. Дело стоит за технологиями.
Есть несколько вариантов организации большого числа клеток, но это тема для отдельной статьи, которую подготовим позже.
**3.Реализация**
**Мультиклеточный процессор «во-плоти»**
Мультиклеточный процессор состоит из N идентичных клеток с номерами от 0 до n-1, объединённых коммутационной средой. Каждая клетка содержит блок памяти программ (PM), устройство управления (CU), буферные устройства (BUF), а также каждой клетке соответствует коммутационное устройство (SU), совокупность которых образует коммутационную среду (SB). Процессор также содержит память данных (DM), блок регистров общего назначения (GPR) и исполнительно устройство(EU), состоящее из арифметико-логического устройства для чисел с плавающей запятой(ALU\_FLOAT), АЛУ для целых чисел(ALU\_INTEGER) и блок доступа к памяти данных(DMS).
Программа для мультиклеточного ассемблера состоит из параграфов. Например:
```
Paragraph:
;Различные команды
jmp paragraph_next ; переход на следующий параграф
complete
```
На самом деле команда перехода на следующий параграф может стоять в любом месте текущего параграфа, но пока мы не заостряем на этом внимание. В данном примере параграф – это все команды от метки “Paragragh” до метки конца участка команд — «complete».
В параграфе команды могут располагаться в произвольном порядке, команды могут ссылаться на результат предыдущих команд с помощью оператора «@», но следует учитывать, что нельзя сослаться на результат команды, которая выше текущей на 64 команды. Т.е. окно видимости результата для каждой команды равно 64, при этом размер параграфа не ограничен, т.е. он может состоять хоть из нескольких тысяч команд. Рассмотрим пример:
```
Paragraph:
getl 2 ;загрузка числа в коммутатор
getl 3 ;загрузка числа в коммутатор
addl @1, @2 ;сложение 2 + 3
addl @1, @3 ;сложение 5 +2
jmp paragraph2
complete
```
В рассматриваемом примере команда addl @1, @2 выполняет сложение двух предыдущих команд, а команда addl @1, @3 выполняет сложение результата предыдущей команды и результат команды, которая на 3 строчки выше.
Состояние процессора меняется при переходах от одного параграфа к другому. Записи в память, регистры происходят по концу параграфа в случае, если контроль чтения записи включён или не используются команды прямого чтения и записи. Но есть возможность отключения контроля чтения и записи, т.е. запись в память будет проходить в самом параграфе, не дожидаясь его завершения (в случаях, когда есть возможность отключить контроль чтения и записи, при работе с памятью может принести ощутимое увеличение производительности). На самом деле выжать максимум из мультиклеточного процессора несложно, но это тема для отдельной статьи.
Для исполнения контекстно-зависимой программы, команды каждого параграфа последовательно, начиная с одного и того же адреса, являющегося адресом данного параграфа, размещают в PM клеток. Адрес размещения первого исполняемого параграфа равен адресу, начиная с которого клетки выбирают команды. В результате, в PM i–ой клетки, начиная с адреса параграфа, последовательно размещаются его команды с номерами i, N+i, 2\*N+i,...,.
Каждая клетка обеспечивает, начиная с указанного ему адреса, последовательную выборку команд и размещение их на регистре команд для последующего декодирования. Команды клетками выбираются синхронно.
При декодировании каждой очередной выбранной группе из N команд присваивают очередное значение тега (t), а команде из группы и, соответственно, ее результату – номер. Выборка и декодирование команд продолжается до тех пор, пока не будет выбрана команда, отмеченная управляющим признаком «конец параграфа»(Complete). Адрес нового параграфа может поступить как в любой момент выборки команд текущего параграфа, так и после завершения выборки команд. Он поступает всем клеткам одновременно. Если к моменту выборки последней команды параграфа адрес следующего параграфа не вычислен, то выборка приостанавливается до получения адреса. Если адрес получен, то выборка продолжается с этого адреса. Выбранная команда поступает в буферное устройство, которое состоит из буфера первого операнда, буфера второго операнда и буфера команд (коды операций, теги и т.п.) Буферные устройства формируют команды и передают их соответствующему исполнительному устройству.
Операционная часть (буфер команд), кроме кода команды, включает в себя всю необходимую служебную информацию для рассылки и приема результатов, а именно, номер команды и признаки готовности первого (второго) операнда для выполнения команды.
Буфер хранения операндов имеет ассоциативную адресацию. Ассоциативным
адресом является тег запрашиваемого результата. В качестве операндов при выполнении операций могут использоваться:
* запрошенные результаты команд–источников, поступающие из коммутатора;
* значения, вычисленные при декодировании командного слова, а также непосредственно присутствующие в командном слове или взятые из регистров общего назначения.
В первом случае признак готовности данного операнда при записи команды устанавливают в состояние «не готов», а во втором – в состояние «готов». После получения запрошенного результата от коммутационного устройства, признак, в первом случае, также устанавливают в состояние «готов». Команда, получившая все операнды, проходит приоритетный отбор среди других готовых команд в буферном устройстве, после чего выдается на исполнение при условии незанятости исполнительного устройства.
В процессоре P1 для каждой клетки был выделен свой участок памяти, т.е. память программ и память данных не пересекались. В процессоре R1 память программ и память данных находятся в одном адресном пространстве, т.е. у клеток есть каналы доступа к памяти программ и памяти данных. На рис 4 приведена общая структура процессора P1. На рис 5 приведена структура клетки и её описание для процессора R1.
Рис 4. Общая структура мультиклеточного процессора
Арифметико-логические устройства (АЛУ), наряду с блоком DMS, входят в состав набора исполнительных устройств имеющегося в каждой клетке (CELL).
В состав клетки входят следующие устройства:
1. Устройство выборки команд IDU (Instruction Distribution Unit).
2. Устройство управления.
3. Коммутационное устройство SU (Switch Unit).
4. Буферное устройство.
5. Целочисленное АЛУ.
6. АЛУ с плавающей точкой.
7. Блок доступа к памяти данных DMS (Data Memory Service).
8. Мультиплексор результатов.
9. Набор регистров GPR (General-Purpose Registers).
10. Контроллер прерываний IC (Interrupt Controller).
11. Отладочный блок JTAG-GPR.
Подробная структура клетки представлена на рисунке 5:
Рис 5. Структура клетки.
Результат выполнения команд исполнительные устройства передают в коммутационное устройство.
Если одновременно готовы результаты выполнения команд целочисленного АЛУ, АЛУ с плавающей точкой и DMS, коммутационное устройство принимает результат выполнения команды АЛУ с плавающей точкой. По приоритету чтения результата исполнительные устройства распределяются следующим образом:
1.АЛУ с плавающей точкой;
2.DMS;
3.Целочисленное АЛУ.
Исполнительные устройства, результат работы которых на текущем такте не может быть выдан в коммутационное устройство, записывают результат выполнения команды в выходной регистр и ожидают своей очереди на выдачу результата.
Описанная выше ситуация имеет следствием то, что количество тактов, необходимое для выполнения команды, является величиной недетерминированной.
В каждой клетке имеются два АЛУ: целочисленное АЛУ и АЛУ обработки чисел с плавающей точкой.
Целочисленное АЛУ предназначено для выполнения команд над целочисленными операндами, при этом операнды могут быть представлены в следующих форматах (в зависимости от команды):
* 64-битные;
* 32-битные;
* 16-битные;
* 8-битные;
* упакованные 32-битные;
* упакованные 16-битные.
АЛУ с плавающей точкой предназначено для выполнения команд над операндами, представленными в формате чисел с плавающей запятой одинарной (32 бита) или двойной точности (64 бита) в соответствии с требованиями стандарта IEEE-754.
Структурно АЛУ с плавающей точкой состоит из трёх частей:
* Делитель одинарной точности (деление, извлечение квадратного корня)
* Делитель двойной точности
* Вычислитель (выполнение остальных команд)
**В чём отличие мультиклеточных процессоров от многоядерных?**
В обычных процессорах, состоящих из одного или нескольких ядер, элементарной единицей исполнения является команда, выполняемая в определённом порядке. В мультиклеточном процессоре элементарной единицей исполнения является параграф, т.е. линейный участок, состоящий из неограниченного количества команд, после которых происходит переход на другой линейный участок с заданной меткой. Команды из этого участка будут выполняться параллельно там, где это возможно. Распараллеливание происходит аппаратно, т.е. программисту не нужно заботиться в какую клетку попадёт команда. Именно это мы и называем «естественный параллелелизм». Вследствие этого один и тот же код может быть выполнен на любом количестве клеток. Ещё одним отличием мультиклеточного процессора является передача результатов работы команд с помощью широковещательной рассылки, тогда как в много и одноядерных системах результаты передаются через память и регистры. Разумеется, в мультиклеточных процессорах имеется память и регистры для передачи данных между линейными участками, но внутри линейного участка основные операции можно провести без использования регистров и памяти. Данный факт даёт мультиклеточной архитектуре простоту реализации и уменьшение обращений к памяти, как следствие снижение энергопотребления. Кроме того выполнение одной и той же программы на одной, двух, …, двухсот пятидесяти шести клетках даёт возможности по реконфигурации (объединение клеток в task-группы) клеток, созданию отказоустойчивого процессора и масштабируемости.
К вопросам параллелилизма и реконфигурации мы ещё вернёмся далее в этой статье.
**4.Примеры**
Мультиклеточный процессор состоит из 4-х клеток (может быть 256 и более), клетки являются полностью равноправными и объединены коммутационной средой (коммутатором). Результат выполнения команд клетки хранят в коммутаторе.
Программа на ассемблере разделяется на секции и на параграфы, которые содержат команды.
Для обмена информацией между клетками служит коммутатор, а для обмена между параграфами существуют РОНы, индексные регистры, память данных. Для работы с периферией существуют периферийные регистры.
Чтобы отсеять высказывания вида:
* Пусть даже это «страница» памяти, но кто «рулит» всей памятью? Где старшее (верхнее) УУ, управляющее клетками? Кто загружает память клеток?
* Параллелит программист, а не процессор
Рассмотрим простую программу:
Рис 2. Распределение команд по клеткам
Как показано на рисунке 2 команды из параграфа будут распределяться по клеткам. Команды в каждых клетках выполняются параллельно («естественный параллелелизм»). Выполнение команд происходит по готовности аргументов. В данном случае программу выполняет группа из 4-х клеток. Программа успешно выполнится как на 4-х, так на любом другом количестве клеток. Основной принцип мультиклеточной архитектуры – клетки независимы друг от друга и от кого-либо и одинаковы. Данный принцип распространяется и на процессоры с реконфигурацией.
Реконфигурация — способность клеток процессора к композиции (сбор) и декомпозиции (разбор) по группам, т.е. возможность клеток объединяться в группы от одной клетки и до N(для N клеточного процессора) и выполнять свой участок кода. По умолчанию при старте любой программы все клетки находятся в одной группе. Стоит отметить, что у каждой группы появляется свой набор РОНов, индексных, управляющих регистров, можно назначить свой обработчик прерываний.
В [статье про архитектуру фон-Неймана](http://www.osp.ru/os/2008/06/5340894/) Леонид Черняк выделяет следующие три вида реконфигурируемых процессоров:
1) специализированные процессоры
2) конфигурируемые процессоры
3) динамически реконфигурируемые процессоры (в качестве примера приводится единственный класс этого вида, существующий на момент опубликования статьи Л.Черняка — FPGA).
Первые два вида приобретают свою специфику в процессе изготовления, а третий может программироваться.
Мультиклеточный процессор R1, в соответствии с этой классификацией, относится к динамически реконфигурируемым, однако это процессор на кристалле и, вследствие независимости машинного кода, перераспределение ресурсов (клеток) в отличие от FPGA происходит без остановки или перезагрузки процессора и без потери информации. Таким образом, MultiClet R1 представляет собой новый класс третьего вида (наряду с первым – FPGA).
На сегодня в мире таких процессоров не делал никто.
Предложенная Л.Черняком классификация, с поправкой на будущее развитие, может быть развита четвертым видом, который сформулируем, как
4) **самоадаптирующиеся процессоры**,
способные самостоятельно обеспечивать работу всех систем, автоматически перераспределяя ресурсы. При повреждении, отказах или при появлении дополнительных задач процессор или система из процессоров должна уметь самоадаптироваться к новым условиям.
Первым шагом к созданию таких систем, возможно, станет процессор Multiclet L1 или СвК на его основе.
Рассмотрим пример декомпозиции (разделения на группы) клеток:
В данном примере мы видим разбиение на 3 группы: клетки с номерами 0 и 1 выполняют вычисления, клетка 2 выполняет сбор информации с датчиков, а клетка 3 составляет отчёты о работе и взаимодействует с внешней средой. Если случилось так, что клетки 0 и 1 не успевают обрабатывать данные, то клетка 3 может придти им на помощь и получатся две группы. Важно заметить, что сброса процессора для реконфигурации клеток не требуется. Клетка 3 будет разговаривать на одном языке с клетками 0 и 1, т.е. приобретёт их набор РОНов, индексных регистров и регистров управления.
Простой пример обычной программы на ассемблере (можно писать и на стандартном Си):
```
.text
habr:
getl 4 ;загрузка константы в коммутатор
getl 5 ; загрузка константы в коммутатор
addl @1, @2 ;сложение 4 + 5 = 9
mull @3, @2 ;умножение 4 * 5 = 20
subl @1, @2 ;вычитание 20 – 9 = 11
slrl @1, 2 ;сдвиг 11 << 2 = 44
subl @1, @2 ;вычитание 44 – 11 = 33
mull @4, @5 ;умножение 20 * 9 = 180
jmp habrahabr ;переход на следующий параграф
complete
habrahabr:
getl 5 ;загрузка константы в коммутатор
addl @1, [10] ;сложение константы и значения из памяти по адресу 10
setl #32, @1 ;запись суммы в регистр номер 32
complete
```
Параграфы находятся в секции размеченной как «.text». Параграф может содержать неограниченное количество команд (пока память программ позволяет), но каждая команда может обратиться за результатом только к команде, которая выше не более чем на 63 строки.
Для удобства в ассемблере можно задать метку к каждой команде, например:
```
habr:
arg1 := getl 5 ;загрузка константы в коммутатор
sum1 := addl @arg1, [10] ;сложение константы и значения из памяти по адресу 10
setl #32, @sum1 ;запись суммы в регистр номер 32
complete
```
В мультиклеточном процессоре нет аппаратных средств, обеспечивающих выявление информационных связей между выбранными операциями (командами) и их распределение по функциональным устройствам, т.е. динамическое распараллеливание отсутствует. Нет и статического распараллеливания, т.к. программа хотя и описывает информационные связи, но имеет линейную форму и не содержит каких-либо указаний, что и как можно выполнять параллельно. В этом состоит принципиальное отличие от других процессоров. Благодаря этой же особенности, потенциально обеспечивается живучесть мультиклеточного процессора, т.е. возможность непрерывного исполнения программы без перекомпиляции или перезагрузки при отказах его отдельных клеток (деградации процессора).
Благодаря свойству мультиклеточного процессора динамически распределять свои ресурсы, мы можем создавать системы способные выполнять задачу даже при отказах части клеток.
Деградация связана с потерей производительности и, соответственно, увеличением времени решения задач. Но, для целого ряда встроенных применений, живучесть мультиклеточного процессора позволяет управляемому объекту выполнять основные функции, либо за счет снижения их качества, либо за счет отказа от решения второстепенных задач.
Асинхронная и децентрализованная организация мультиклеточного процессора, как на системном уровне – между клетками (при реализации параллелизма), так и на внутриклеточном уровне – между блоками клетки (при реализации команд), дополнительно обеспечивает:
* минимизацию номенклатуры объектов проектирования и уменьшение их
сложности;
* уменьшение площади кристалла процессора (объем оборудования при
децентрализованном управлении меньше, чем при централизованном);
* увеличение производительности и сокращение энергопотребления за счет
реализации более эффективного вычислительного процесса;
* использование индивидуальной системы синхронизации для каждой клетки
при реализации на одном кристалле десятков и сотен клеток.
В результате, получается хорошо структурированная и модульная система, позволяющая резко уменьшить сложность процессора и, соответственно, снизить затраты и повысить качество проектирования. При этом по сравнению с фон-неймановской моделью, улучшаются и количественные характеристики процессора.
На данный момент проведены тесты простых алгоритмов, таких как POCNT и алгоритмов шифрования. Для теста popcnt была написана программа на ассемблере и результат мы сравнили с простой программой для Pentium Dual Core 5700 на Си.
Результаты тестирования можно свести в следующую таблицу (количество тактов на один цикл расчёта 32-х бит):
Т.е. можно сделать вывод, что процессор Мультиклет R1 на тесте «table» быстрее процессора Intel на 15%, а на тесте BitHacks процессор Мультиклет R1 быстрее чем Intel более чем в 2 раза. Тест popcnt для мультиклеточного процессора был достаточно просто преобразован для параллельных вычислений. Конечно, в новых процессорах Intel существует аппаратная реализация popcnt, но в данном тесте мы показали возможности наших процессоров.
**5.Что у нас есть сейчас**
На данный момент выпущен процессор Multiclet P1 и он доступен для заказа, а также две отладочные платы.
Кроме того на первом мультиклеточном процессоре разработано устройство для защиты информации Multiclet Key\_P1, первая серийная партия запланирована на сентябрь 2014 года.
Кроме того на базе процессора Р1 был разработан и поставляется серийно принтер для тиснения фольгой от компании ООО Виршке.
Пользователи активно осваивают мультиклеточные процессоры и дополняют библиотеки, а также создают новые полезные примеры.
Получена первая партия процессоров R1, начато тестирование новых процессоров.
Первая ревизия процессора называется R1-1.
Опять же новый процессор – тема для отдельной статьи, характеристики процессора первой ревизии опубликуем чуть позже.
Для данного процессора компания LDM-Systems выпустила отладочную плату, состоящую из базовой и процессорной. На фотографии версия с колодкой. Пользовательская версия будет немного отличаться. Комплектацию базовой платы можно будет выбирать под свои задачи, в максимальной комплектации базовая+процессорная платы будут иметь приемлемую стоимость.
Комплект ПО включает:
• Ассемблер
• Си компилятор
• Функциональная модель
• Библиотеки
• Отладчик для IDE Geany
• ОС FreeRTOS
• Примеры программ
• Графопостроитель
P.S. Если вам понравилась данная статья несмотря на большой объём, то могу написать продолжение по программированию процессоров, обзор процессора R1 и принципы построения высокопроизводительных систем на мультиклеточных процессорах.
**UPD:** Программа для проверки времени работы алгоритма popcnt взята с сайта [www.strchr.com/crc32\_popcnt](http://www.strchr.com/crc32_popcnt). Как уже отмечалось в статье, для процессоров Интел существуют и другие более быстрые алгоритмы реализации теста popcnt, которые требуют определенных команд, реализованных на аппаратном уровне. Для оценки возможностей мультиклеточной архитектуры были взяты алгоритмы Table и Bit hacks.
**UPD2:** Обновлен рисунок 2. Команда add @3, @2 должна быть растянута на две строки, а команда mpy @4, @3 была уменьшена по длительности, т.к. аргументы для неё были готовы раньше, что уменьшило и общую длительность параграфа. Также команда mpy заменена на mul.
**UPD3:** Каждая клетка содержит буфер на 64 команды. Выборка команд параграфа клетками продолжается параллельно с выполнением, выборка следующего параграфа может быть начата, только в случае если известен адрес перехода на него. | https://habr.com/ru/post/226773/ | null | ru | null |
# Управление компьютером без рук (гироскоп мне в темя!)
В [предыдущей статье](/post/208108/) я рассказал, как можно управлять компьютером при помощи глаз. Несмотря на то, что в ряде случаев отслеживание положения зрачков (eye gaze tracking) — единственный способ предоставить больному человеку возможность общаться с окружающим миром, описанная ранее система не лишена недостатков. Прежде всего, это необходимость использовать компоненты, которые трудно приобрести в России. Кроме того, человеку в очках приходится сильно ограничивать положение головы, чтобы свести к минимуму паразитные блики на поверхности очков и достичь стабильной работы системы.
А можно ли использовать что-нибудь попроще и понадёжнее, если человек способен двигать головой, но испытывает трудности при работе руками?
**-= Обновление января 2019 года =-**
Описываемый в статье пульт **Upvel UM-510KB** уже невозможно купить, но вместо него для отслеживания поворота головы можно использовать вот такую схему, собраную из **Arduino Leonardo** и модуля **GY-521** с гироскопом/акелерометром **MPU-6050**.
Arduino Leonardo и GY-521 соединяются четырьмя проводами. По возможности припаяйте их.
У меня получился вот такой прототип. Естественно, по-хорошему нужно всё это облагородить/поместить в корпус.
| | |
| --- | --- |
| | |
Программа (скетч), которую нужно загрузить в Arduino, выглядит вот так:
```
#include "I2Cdev.h"
#include "MPU6050_6Axis_MotionApps20.h"
#include "Wire.h"
#include
MPU6050 mpu;
uint16\_t packetSize; // expected DMP packet size (default is 42 bytes)
uint16\_t fifoCount; // count of all bytes currently in FIFO
uint8\_t fifoBuffer[64]; // FIFO storage buffer
// orientation/motion vars
Quaternion q; // [w, x, y, z] quaternion container
VectorFloat gravity; // [x, y, z] gravity vector
float ypr[3]; // [yaw, pitch, roll] yaw/pitch/roll container and gravity vector
// для мыши
float old\_mx=-200;
float old\_my=-200;
float dx,dy,mx,my;
// ================================================================
// === INITIAL SETUP ===
// ================================================================
void setup()
{
Wire.begin();
Wire.setClock(400000); // 400kHz I2C clock. Comment this line if having compilation difficulties
mpu.initialize();
mpu.dmpInitialize();
mpu.setDMPEnabled(true);
packetSize = mpu.dmpGetFIFOPacketSize();
}
// ================================================================
// === MAIN PROGRAM LOOP ===
// ================================================================
void loop() {
// wait for MPU interrupt or extra packet(s) available
while (fifoCount < packetSize)
{
fifoCount = mpu.getFIFOCount();
}
// check for overflow (this should never happen unless our code is too inefficient)
if ( fifoCount >= 1024) {
// reset so we can continue cleanly
mpu.resetFIFO();
fifoCount = mpu.getFIFOCount();
// otherwise, check for DMP data ready interrupt (this should happen frequently)
} else {
// wait for correct available data length, should be a VERY short wait
while (fifoCount < packetSize) fifoCount = mpu.getFIFOCount();
// read a packet from FIFO
mpu.getFIFOBytes(fifoBuffer, packetSize);
// track FIFO count here in case there is > 1 packet available
// (this lets us immediately read more without waiting for an interrupt)
fifoCount -= packetSize;
// двигать мышь
mpu.dmpGetQuaternion(&q, fifoBuffer);
mpu.dmpGetGravity(&gravity, &q);
mpu.dmpGetYawPitchRoll(ypr, &q, &gravity);
// ypr[0] - ось X, ypr[1] - ось Y, Y - инвертировать
mx=ypr[0] \* 180/M\_PI;
my=ypr[1] \* 180/M\_PI;
if(old\_mx>-200) // это не первый запуск
{
if((old\_mx<-100)&&(mx>100))
{
dx=(-180-old\_mx)+(mx-180);
}
else if((old\_mx>100)&&(mx<-100))
{
dx=(180-old\_mx)+(180+mx);
}
else
{
dx=mx-old\_mx;
}
dy=my-old\_my;
Mouse.move(2000/60\*dx, -1000/30\*dy);
}
old\_mx=mx;
old\_my=my;
}
}
```
Для компиляции скетча также необходимо скачать библиотеки I2Cdev и MPU6050. Взять их можно вот отсюда: [github.com/jrowberg/i2cdevlib/tree/master/Arduino](https://github.com/jrowberg/i2cdevlib/tree/master/Arduino)
После загрузки скетча собранное устройство действует так же, как и пульт из статьи. То есть вы меняете ориентацию устройства в пространстве, а курсор мыши на экране двигается.
**-= далее — оригинал статьи=-**
А можно ли использовать что-нибудь попроще и понадёжнее, если человек способен двигать головой, но испытывает трудности при работе руками?
Конечно, такие средства существуют. Прежде всего, это программы, которые используют обычную веб-камеру для контроля за поворотом головы и некоторыми другими действиями, такими как моргания глаз и движения губ (читайте про них ниже, в разделе "**А стоит ли овчинка выделки?**").
Кроме того, выпускаются и специализированные устройства, которые также представляют из себя **камеры, следящие за маркерами, ярко светящимися в инфракрасном диапазоне**. Маркеры крепят куда-нибудь в район головы, например, на оправу очков, кепку, гарнитуру. Иногда даже рекомендуют приклеить маркер на лоб.
Различные фирмы, которые ранее производили устройства такого типа, постепенно собрались под крылом компании [NaturalPoint](http://www.naturalpoint.com/). И теперь у них на сайте можно найти устройства, которые раньше конкурировали, а теперь просто делят разные сегменты рынка. Так, например, вариант попроще ([TrackIR](http://www.naturalpoint.com/trackir/)) они предлагают для геймеров, а подороже ([SmartNav](http://www.naturalpoint.com/smartnav/)) — для работы за компьютером.
И без того недешёвый [SmartNav](http://www.naturalpoint.com/smartnav/) ($500) становится просто золотым, когда пытаешься приобрести его в России. Поэтому возникла идея сотворить нечто, что могло бы не хуже позиционировать курсор на экране компьютера, но при этом было бы доступнее.
Поначалу хотелось использовать тот же принцип работы: маркеры, подсветка, обработка изображения. Но приходили мысли и о прямых измерениях. Вплоть до того, чтобы приделать к голове **электронный штангенциркуль** (почти шутка).
Как впоследствии оказалось, такие приборы действительно существуют!
Посмотрите-ка вот на [это чудо инженерной мысли](http://www.jouse.com/jouse3/home) — рычаг, который нужно держать ртом, и управлять им движениями головы!
Неожиданно появилась идея использовать [электронный] гироскоп. Они в последнее время стали доступны и весьма точны. Готовые устройства типа «аэромышь», правда, не получили большого распространения. Например, мышь **Logitech MX Air** уже снята с производства, видимо, из-за отсутствия спроса.
Существуют программы для смартфонов (как iPhone, так и Android), которые позволяют использовать их в качестве аэромыши, задействуя встроенные в них гироскопы. Но глубоко этот вопрос я не исследовал, так как интересовало, прежде всего, дешёвое решение.
Наконец в поле зрения попали пульты для мультимедия-приставок к телевизорам, также использующие встроенный гироскоп. Некоторые из них работают и с обычным компьютером, достаточно лишь вставить адаптер в USB-гнездо. Передача данных происходит по радиоканалу, то есть не требуется прямой видимости пульта, как в случае с инфракрасными приёмопередатчиками.
Пульт закрепляется на голове, и при её повороте курсор мыши на экране движется (как у Чебурашки в заголовке статьи). Остаётся только разобраться с нажатиями на кнопки мыши и виртуальной клавиатурой. Для этих целей я написал [свою программу](https://github.com/MastaLomaster/bkb).
Сложность представляет следующий момент: пульты «засыпают» после некоторого периода бездействия, и пробуждать их нужно нажатием на кнопку, что может быть сложно для использующего их человека.
Пришлось поставить ряд экспериментов — зажимать одну из кнопок на клавиатуре и оставлять пульт в бездействии, надеясь, что нажатая кнопка не даст пульту заснуть. Причём зажимать кнопку приходилось прищепкой, а не рукой, так как рука могла передавать пульту небольшие движения. Кнопки же можно было нажимать только те, которые не используются в Windows.
Некоторые пульты победить не удалось, но в конце концов был найден пульт **Upvel UM-510KB**, который гарантированно не засыпает при удержании пары кнопок.
Если вскрыть этот пульт, то внутри можно найти микроконтроллер STM8L-151 от STMicroelectronics (1), трёхосевой гироскоп Invensense MPU-3050c (2) и ещё какой-то безымянный чип (3) для общения с USB- адаптером на 2.4 ГГц. Также виден инфракрасный светодиод. Он нужен, если вы хотите использовать пульт для переключения программ и регулировки громкости на телевизоре. При общении с компьютером светодиод не используется, поэтому его можно смело загораживать.
Конечно, красивым решением было бы прочитать, дизассемблировать и модифицировать программу микроконтроллера, а затем перепрошить его, чтобы пульт не засыпал, а не закорачивать кнопки. Но с этой областью я не знаком, оставляю такую возможность энтузиастам.
Пульт с постоянно нажатыми кнопками прожорливо потребляет электроэнергию. Поэтому пришлось припаять к нему блок питания, чтобы каждый день не менять батарейки.
### Переделка шаг за шагом
*Прежде всего отмечу, что то, что у меня всё заработало, не значит, что оно заработает у вас. Если производитель, например, поменяет прошивку, то замыкание двух кнопок может оказаться бесполезным. Однако, надеюсь, что прошивку менять никто не будет за ненадобностью.*
Итак, вскрываем пульт. Ковыряем отверткой, пока он не откроется, немного повредив корпус. Затем, вынимаем плату и замыкаем ему две кнопки (см. фото). Можно паяльником, зачистив плату, но я просто приклеил армированным скотчем кусочки фольги от конфет.
Подпаиваем питание от трёхвольтового стабилизированного источника питания.
По вкусу заливаем клеем, чтобы провод держался в корпусе прочно.
| | | |
| --- | --- | --- |
| | | |
| Замкнуть ДВЕ (!) кнопки в указанных местах. **Внимание! Изначально фотография содержала ошибочно помеченные кнопки! Нужно замыкать кнопку «Set» и кнопку с четырьмя квадратиками, расположенную слева от «ОК»** | Укрепить провод | В сборе |
Как удерживать пульт на голове? Можно просто положить пульт на голову и сверху надеть шерстяную шапочку. Так я поначалу и делал. Но для долговременного использования можно пришить кармашек к какому-нибудь головному убору.
Точного положения пульта относительно головы не требуется. Если курсор мыши находится не там, где вы бы хотели, просто поворачивайте голову так, чтобы курсор начал упираться в край экрана. Это сдвинет курсор в сторону, противоположную вращению головы. Короче говоря, попробуйте, и всё станет понятно без объяснений.
### А стоит ли овчинка выделки?
Уже после того, как всё было сделано, я решил для сравнения попробовать программы, которые используют обычную веб-камеру для управления мышью без рук. Каково же было моё удивление, когда все они отлично заработали! Если ничего другого под рукой нет, рекомендую ими воспользоваться.
Попробовал же я такие программы (все бесплатные):
* [eViaCam](http://sourceforge.net/projects/eviacam/)
* [Head Mouse](http://robotica.udl.cat/)
* [Camera Mouse](http://www.cameramouse.org/)
Лично мне больше всего понравилась программа **eViaCam**, но это — чисто субъективное, поверхностное мнение, основанное на недолгом использовании с настройками по умолчанию, и с той веб-камерой, которая есть у меня. Вам, возможно, понравится совсем другая программа.
Чтобы оценить преимущества использования гироскопа над чисто программными решениями, я написал программу, в которой нужно перемещать курсор вслед за появляющимися на экране квадратиками. При этом курсор мыши должен остановиться (зафиксироваться) над квадратиком хотя бы на 0.2 секунды.
Показывается два квадратика: красный — куда нужно вести мышь, и зелёный — то место, куда переместится красный на следующем шаге.
Программа и её исходный код доступны на <https://github.com/MastaLomaster/CStest>
В результате были получены следующие времена перемещения курсора по 25 квадратикам 40x40 пикселов (косвенно более высокая скорость свидетельствует также о большей точности позиционирования):
| | |
| --- | --- |
| обычная мышь в руке | 28.3 секунды |
| пульт с гироскопом на голове | 36.7 секунды |
| eViaCam | 58,3 секунд |
| Head Mouse | 66,3 секунды |
| Camera Mouse | 48,4 секунды |
Скорость набора текста на виртуальной клавиатуре менее показательна. Дело в том, что клавиатура требует, чтобы курсор мыши «зависал» над клавишей в течение продолжительного времени (около секунды). Иначе возможны ложные нажатия. Тем не менее, привожу данные и по набору текста. Я набирал текст «Управление компьютером без помощи рук» и это заняло у меня:
| | |
| --- | --- |
| обычная мышь в руке | 1 минута 15 секунд |
| пульт с гироскопом на голове | 1 минута 23 секунды |
| eViaCam | 1 минута 31 секунда |
| Head Mouse | 1 минута 44 секунды |
| Camera Mouse | 1 минута 28 секунд |
Camera Mouse — мне понравилась меньше всего, из-за того, что курсор у неё не стоит на месте, а дёргается. Но скорость набора текста в ней получилась неплохая.
Использовалась программа, которую я написал для работы с устройством слежения за глазами Tobii REX, а впоследствии модифицировал для поддержки любого устройства, перемещающего курсор по экрану, в том числе аэромыши.
Сама программа и её исходный код доступны здесь: <https://github.com/MastaLomaster/bkb>
Иллюстрация работы программы с устройством слежения за глазами — здесь: <http://www.youtube.com/watch?v=O68C4d2SNC8>
С другими устройствами программа работает точно так же, только курсор перемещается не от движения глаз, а, например, от поворота головы с гироскопом.
Стоит ли всё-таки выбрасывать около тысячи рублей за пульт, блок питания, провода, да ещё время терять, если есть бесплатные программы, с которыми тоже можно работать, да ещё к голове ничего цеплять не нужно?
На мой взгляд, использование пульта даёт следующие преимущества:
* **Быстрая реакция** курсора. вплоть до того, что можно играть в динамичные игры
* **Предсказуемость**. То есть повернув голову на привычный угол, вы увидите, что курсор переместился на привычное место
* **Независимость от условий освещения** и вообще от того, что в кадре появились новые лица/предметы.
Ну а решать, конечно, вам. | https://habr.com/ru/post/213715/ | null | ru | null |
# О C++ и объектно-ориентированном программировании
Привет, Хабр!
Вашему вниманию предлагается статья, автор которой не одобряет сугубо объектно-ориентированного подхода при работе с языком С++. Просим вас по возможности оценить не только авторскую аргументацию, но и логику, и стиль.
В последнее время много [пишут](http://aras-p.info/blog/2018/12/28/Modern-C-Lamentations/) о [C++](https://mikelui.io/2019/01/03/seriously-bonkers.html) и о том, в каком направлении развивается этот язык и о том, что большая часть того, что именуется «современным C++» — просто не вариант для разработчиков игр.
Пусть я и полностью разделяю данную точку зрения, я склонен рассматривать эволюцию C++ как результат укоренения всепроникающих идей, на которые ориентируется большинство разработчиков. В этой статье я попытаюсь упорядочить некоторые из этих идей наряду с моими собственными мыслями — и, возможно, у меня получится что-то стройное.
Об объектно-ориентированном программировании (ООП) как инструменте
------------------------------------------------------------------
Хотя C++ и описывается как [мультипарадигмальный](https://en.wikipedia.org/wiki/C%2B%2B) язык программирования, на практике большинство программистов используют C++ сугубо как объектно-ориентированный язык (обобщенное программирование используется для «дополнения» ООП).
Предполагается, что ООП – это инструмент, одна из многих парадигм, которыми может пользоваться программист для решения задач в коде. Однако, как подсказывает мой опыт, ООП большинством профессионалов принимается за золотой стандарт разработки программного обеспечения. В принципе, разработка решения начинается с определения того, какие объекты нам понадобятся. Решение конкретной задачи начинается уже после того, как код будет распределен по объектам. При переходе к такому объектно-ориентированному мышлению ООП превращается из инструмента в целый инструментарий.
Об энтропии как тайной силе, подпитывающей разработку ПО
--------------------------------------------------------
Мне нравится представлять решение в стиле ООП как созвездие: это группа объектов, между которыми произвольно прочерчены линии. Такое решение вполне можно рассматривать и как граф, в котором объекты являются узлами, а отношения между ними – ребрами, но мне ближе феномен группы/кластера, который передается метафорой созвездия (по сравнению с ней граф слишком абстрактен).
Но мне не нравится, каким образом составляются такие «созвездия объектов». В моем понимании, каждое такое созвездие – не более чем мгновенный снимок образа, сложившегося в голове у программиста и отражающего, как выглядит пространство решения в конкретный момент. Даже учитывая все обещания, которые даются при объектно-ориентированном проектировании по поводу расширяемости, многократного использования, инкапсуляции, т.д… будущее непредсказуемо, поэтому в каждом конкретном случае мы можем предложить решение ровно для той задачи, что стоит перед нами сейчас.
Нас должно обнадеживать, что мы «просто» решаем ту задачу, что непосредственно перед нами поставлена, но, по моему опыту, программист, использующий принципы проектирования в духе ООП, создает решение, при этом сковывая себя допущением, что сама задача существенно не изменится и, соответственно, решение можно считать перманентным. Я имею в виду, что отсюда и далее о решении начинают рассуждать в терминах объектов, образующих вышеупомянутое созвездие, а не в терминах данных и алгоритмов; саму проблему абстрагируют.
Тем не менее, программа подвержена энтропии не в меньшей степени, чем любая иная система и, следовательно, все мы знаем, что код будет меняться. Причем, непредсказуемым образом. Но для меня в данном случае совершенно ясно, что код в любом случае будет деградировать, скатываясь в хаос и беспорядок, если с этим сознательно не бороться.
Я видел, как это самым разным образом проявляется в ООП-решениях:
* В иерархии возникают новые промежуточные уровни, тогда как изначально вводить их не предполагалось.
* Добавляются новые виртуальные функции с пустыми реализациями в большей части иерархии.
* Один из объектов в созвездии требует большей обработки, чем планировалось, из-за чего связи между остальными объектами начинают пробуксовывать.
* В иерархию добавляются обратные вызовы, так, что объекты одного уровня могут обмениваться информацией с объектами другого уровня, при этом не обладая явным знанием друг о друге.
* Т.д…
Все это – примеры неправильно организованной расширяемости. Причем, исход у этого всегда один, он может наступить через несколько месяцев, а может через несколько лет. При помощи **рефакторинга** пытаются устранить нарушения ООП-принципов проектирования, допущенные, когда в созвездие добавлялись новые объекты, а добавлялись они по причине переформулировки самой задачи. Иногда рефакторинг помогает. На некоторое время. Энтропия неуклонна, а у программистов нет времени на рефакторинг каждого ООП-созвездия, чтобы ее побороть, поэтому любой проект исправно оказывается в одной и той же ситуации, имя которой — хаос.
В жизненном цикле любого ООП-проекта рано или поздно наступает такой момент, после которого поддерживать его невозможно. Как правило, в такой момент следует предпринять одно из двух действий:
* Перейти к «черному ящику»: скрыть созвездие за каким-нибудь фасадом и медленно вытягивать его из остальной части кода. Система может и далее решать исходную задачу, для которой создавалась, если пока еще работает прилично, но разработка новых фич полностью останавливается, а исправление багов требует очень много времени, если вообще приводит к успеху.
* Переписать с чистого листа: ООП-дизайн, созданный для решения исходной проблемы, уже так далек от ее текущего состояния, что никаким постепенным рефакторингом его не подстроить под актуальное решение.
Обратите внимание: вариант с черным ящиком все равно потребует переписывания в случае, если разработку новых фич придется продолжить и/или сохранится необходимость в устранении багов.
Ситуация с переписыванием решения возвращает нас к феномену мгновенного снимка имеющегося пространства решений в конкретный момент. Итак, что же изменилось между ООП-дизайном #1 и ситуацией текущего момента? В принципе, все. Проблема изменилась, следовательно, и решение для нее требуется иное.
Пока мы писали решение, следуя принципам ООП-проектирования, мы абстрагировали проблему, и, как только она изменилась, наше решение развалилось как карточный домик.
Думаю, именно в этот момент мы начинаем задумываться, что же пошло не так, пробуем пойти другим путем и обновить стратегии решения задачи на основании результатов постмортема (разбора полетов). Однако всякий раз, когда я сталкиваюсь с таким сценарием «пора переписывать», ничего не меняется: в ход снова идут принципы ООП, в соответствии с которыми воплощается новый мгновенный снимок, соответствующий актуальному состоянию пространства задачи. Весь цикл повторяется.
О легкости удаления кода как о принципе проектирования
------------------------------------------------------
В любой системе, построенной по принципу ООП, именно объектам в составе «созвездия» уделяется основное внимание. Но я считаю, что взаимосвязи между объектами важны не менее, если не более, чем сами объекты.
Я предпочитаю простые решения, при которых граф зависимостей кода состоит из минимального количества узлов и ребер. Чем проще решение, тем легче его не только изменить, но и удалить. А также я обнаружил, что, чем проще удалить код, тем быстрее можно переориентировать решение и адаптировать его к изменяющимся условиям задачи. В то же время, код становится более устойчив к энтропии, поскольку требуется гораздо меньше усилий, чтобы поддерживать его в порядке и не дать ему скатиться в хаос.
О производительности по определению
-----------------------------------
Но одно из основных соображений, по которым избегается ООП-дизайн – это производительность. Чем больше кода вам требуется запускать, тем хуже будет производительность.
Также невозможно не отметить, что ООП-фичи по определению не блещут производительностью. Я реализовал простую ООП-иерархию с интерфейсом и двумя производными классами, которые переопределяют единственный вызов чистой виртуальной функции в [Compiler Explorer](https://gcc.godbolt.org/z/1nftf-).
Код из этого примера либо выводит на экран “Hello, World!”, либо нет, в зависимости от количества аргументов, переданных программе. Вместо того, чтобы прямо запрограммировать все, что я сейчас описал, для решения данной задачи в коде будет использоваться один из стандартных паттернов проектирования ООП, наследование.
В данном случае наиболее бросается в глаза, какую кучу кода генерируют компиляторы, даже после оптимизации. Затем, присмотревшись, можно заметить, как затратно и при этом бесполезно такое сопровождение: когда программе передается ненулевое количество аргументов, код все равно выделяет память (вызов `new`), загружает адреса `vtable` обоих объектов, загружает адрес функции `Work()` для `ImplB` и перескакивает к ней, чтобы затем сразу же вернуться, так как делать там нечего. Наконец, вызывается `delete`, чтобы высвободить выделенную память.
Ни одна из этих операций совершенно не была необходимой, но процессор исправно исполнил их все.
Таким образом, если среди первоочередных целей вашего продукта есть достижение высокой производительности (странно, если было бы иначе), то в коде нужно избегать ненужных затратных операций, предпочитая им простые, о которых легко судить, и использовать конструкты, помогающие достичь этой цели.
Возьмем, к примеру, [Unity](https://unity.com/). В рамках принятой у них в последнее время практики **производительность – это корректность** используется C#, объектно-ориентированный язык, поскольку этот язык уже применяется в самом движке. Однако, они остановились на [подмножестве C#](http://lucasmeijer.com/posts/cpp_unity/), причем, на таком, которое жестко не привязано к ООП, и на его основе создают конструкты, заточенные на высокую производительность.
Учитывая, что работа программиста – решать задачи, пользуясь компьютером, немыслимо, что в нашем деле так мало внимания уделяется созданию кода, который по-настоящему заставляет процессор выполнять работу, в которой процессор особенно хорош.
О борьбе со стереотипами
------------------------
В статье [Анджело Песке](https://twitter.com/kenpex) «[Переусложнение – корень всего зла](https://c0de517e.blogspot.com/2016/10/over-engineering-root-of-all-evil.html)» автор попадает в самую точку (см. последний раздел: People) признавая, что большинство софтверных проблем на самом деле обусловлено человеческим фактором.
Людям в команде необходимо взаимодействовать и выработать общее представление о том, какова общая цель, и каков путь для ее достижения. Если в команде возникает несогласие, например, по поводу пути к цели, то для дальнейшего продвижения необходимо выработать консенсус. Обычно это не составляет труда, если различия во мнениях невелики, но гораздо тяжелее переносится, если варианты отличаются фундаментально, скажем «ООП или не ООП».
Менять мнение непросто. Усомниться в своей точке зрения, осознать, насколько неправы вы были и скорректировать курс – тяжело и болезненно. Но куда сложнее изменить мнение кого-то другого!
Мне много доводилось беседовать с разными людьми об ООП и присущих ему проблемах и, хотя я считаю, что мне всегда удавалось объяснить, почему я думаю так, а не иначе, не думаю, что мне удалось кого-то отвратить от ООП.
Правда, за годы работы я выделил для себя три основных аргумента, из-за которых люди не готовы дать шанс другой стороне:
* «С хорошим ООП так бы не вышло». «Это плохо спроектированное ООП». «Этот код не следует принципам ООП» и тому подобное. Слышал такие вещи, когда демонстрировал примеры ООП, заведшего во все тяжкие (как я уже говорил выше, с ООП-кодом такое происходит неизбежно). Это типичный пример логического заблуждения «Ни один истинный шотландец…».
* «Я знаю ООП, и, если начинать с чистого листа, то больше ничем пользоваться не хочу». Это страх потерять свой «сеньорский» статус после того, как на протяжении всей карьеры пользовался принципами ООП и руководил другими людьми, от которых также требовал использовать эти принципы. Я считаю, что здесь мы имеем дело с примером «ошибки невозвратных издержек».
* «Все знают ООП, очень удобно говорить с людьми на общем языке, обладая общими знаниями». Это логическая ошибка, называемая «аргумент к народу», то есть, если практически все программисты пользуются принципами ООП, то эта идея не может быть неподходящей.
Я совершенно осознаю, что выявить в аргументации логические ошибки – это еще недостаточно, чтобы развенчать их. Однако, я верю, что, видя изъяны в собственных суждениях, можно докопаться до истины и найти глубинную причину, по которой ты отвергаешь непривычную идею. | https://habr.com/ru/post/528176/ | null | ru | null |
# uLogin на ASP.Net сайте
Потребовалось на днях прикрутить uLogin к asp.net сайту, но с ходу найти готовый код как-то не получилось. Определенно кто-то столкнется с данным вопросом…
На мой выбор использовать ли uLogin ([обзор на хабре](http://habrahabr.ru/post/130893/)) в своих проектах повлияли [некоторые цифры](http://www.liveinternet.ru/rating/ru/month.html). Не будем вдаваться в авторитетность ресурса, мне, почему-то, этого было достаточно. Сервис достаточно просто и удобно сделан — указываешь адрес своего сайта, выбираешь кнопки нужных провайдеров авторизации и получаешь пару кусков кода, которые нужно разместить на своем сайте. Если html код не особо зависит от того на чем создан сайт, то предлагаемый php код мне как-то не подошел. В итоге получилось то, что получилось :)
Полученный html я разместил на master странице сайта.
> `1. <script src="http://ulogin.ru/js/ulogin.js">script>
> 2. <div id="uLogin" x-ulogin-params="display=small;optional=email,sex;fields=first\_name,last\_name,photo;providers=vkontakte,facebook,twitter,odnoklassniki,google;hidden=yandex,mailru,livejournal,openid,liveid;redirect\_uri=http%3A%2F%2Fmysite.ru%2Fauth.aspx">div>
> \* This source code was highlighted with Source Code Highlighter.`
В адресе redirect\_uri указано куда пошлют пользователя (с токеном uLogin) после того как он пройдет авторизацию через выбранный им провайдер. Получив token, нужно сходить на uLogin и спросить данные о пользователе.
> `1. string link = string.Format("http://ulogin.ru/token.php?token={0}&host={1}", Request.Form["token"],
> 2. Request.ServerVariables["SERVER\_NAME"]);
> 3.
> 4. WebRequest reqGET = WebRequest.Create(link);
> 5. string answer = "";
> 6.
> 7. using (WebResponse resp = reqGET.GetResponse())
> 8. {
> 9. using (Stream stream = resp.GetResponseStream())
> 10. {
> 11. if (stream != null)
> 12. using (StreamReader sr = new StreamReader(stream))
> 13. {
> 14. answer = sr.ReadToEnd();
> 15. }
> 16. }
> 17. }`
В ответ получаем jSON строку, с которой я решил разделаться следующим образом:
> `1. public class JSONHelper
> 2. {
> 3. public static T Deserialise(string json)
> 4. {
> 5. T obj = Activator.CreateInstance();
> 6. using (MemoryStream ms = new MemoryStream(Encoding.Unicode.GetBytes(json)))
> 7. {
> 8. DataContractJsonSerializer serialiser = new DataContractJsonSerializer(obj.GetType());
> 9. obj = (T)serialiser.ReadObject(ms);
> 10. }
> 11. return obj;
> 12. }
> 13. }
> 14.
> 15. public class iUser
> 16. {
> 17. public string Network { get; set; }
> 18. public string Uid { get; set; }
> 19. public string FirstName { get; set; }
> 20. public string LastName { get; set; }
> 21. public string Email { get; set; }
> 22. public string Sex { get; set; }
> 23.
> 24. public override string ToString()
> 25. {
> 26. return string.Format("network={0},uid={1},first\_name={2},last\_name={3}", Network, Uid, FirstName, LastName);
> 27. }
> 28. }`
У uLogin можно спрашивать еще [несколько других атрибутов](http://ulogin.ru/faq.html). Я добавил некоторые в параметр optional чтобы не нервировать пользователя лишними вопросами (допустим ввод email адреса, если провайдер не может передать его)
Осталось десериализовать:
> `1. iUser usr = JSONHelper.Deserialise(answer);`
Ну, а дальше каждый решает сам что делать с полученными данными. Как пример — положить себе в базу и отправить пользователю куку с токеном, для авторизации на сайте.
Тестировал на своих аккаунтах. Может быть более обширное использование сможет выявить имеющиеся баги.
Надеюсь что решение получилось не только короткое, но и полезное. | https://habr.com/ru/post/142631/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.